Struct tfhe::FheBool

pub struct FheBool { /* private fields */ }

Available on crate feature integer only.

The FHE boolean data type.

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let config = ConfigBuilder::default().build();

let (client_key, server_key) = generate_keys(config);

let ttrue = FheBool::encrypt(true, &client_key);
let ffalse = FheBool::encrypt(false, &client_key);

// Do not forget to set the server key before doing any computation
set_server_key(server_key);

let fhe_result = ttrue & ffalse;

let clear_result = fhe_result.decrypt(&client_key);
assert_eq!(clear_result, false);

Implementations

impl FheBool

pub fn current_device(&self) -> Device

pub fn move_to_device(&mut self, device: Device)

Moves (in-place) the ciphertext to the desired device.

Does nothing if the ciphertext is already in the desired device

pub fn try_decrypt_trivial(&self) -> Result<bool, NotTrivialCiphertextError>

Tries to decrypt a trivial ciphertext

Trivial ciphertexts are ciphertexts which are not encrypted meaning they can be decrypted by any key, or even without a key.

For debugging, it can be useful to use trivial ciphertext to speed up execution, and use Self::try_decrypt_trivial to decrypt temporary values and debug.

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

// This is not a trivial ciphertext as we use a client key to encrypt.
let non_trivial = FheBool::encrypt(false, &client_key);
// This is a trivial ciphertext
let trivial = FheBool::encrypt_trivial(true);

// We can trivial decrypt
let result: Result<bool, _> = trivial.try_decrypt_trivial();
assert_eq!(result, Ok(true));

// We cannot trivial decrypt
let result: Result<bool, _> = non_trivial.try_decrypt_trivial();
matches!(result, Err(_));

pub fn is_trivial(&self) -> bool

Returns true if the ciphertext is a trivial encryption

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let non_trivial = FheBool::encrypt(false, &client_key);
assert!(!non_trivial.is_trivial());

let trivial = FheBool::encrypt_trivial(true);
assert!(trivial.is_trivial());

impl FheBool

pub fn compress(&self) -> CompressedFheBool

Trait Implementations

impl BitAnd<&FheBool> for bool

fn bitand(self, rhs: &FheBool) -> Self::Output

Performs a bitwise ‘and’ between a bool and a FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = false & &a;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, false & true);

type Output = FheBool

The resulting type after applying the & operator.

impl<B> BitAnd<B> for &FheBool

where B: Borrow<FheBool>,

fn bitand(self, rhs: B) -> Self::Output

Performs a bitwise ‘and’ between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(true, &client_key);

let result = &a & &b;
let result = result.decrypt(&client_key);
assert_eq!(result, true & true);

type Output = FheBool

The resulting type after applying the & operator.

impl<B> BitAnd<B> for FheBool

where B: Borrow<Self>,

fn bitand(self, rhs: B) -> Self::Output

Performs a bitwise ‘and’ between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(true, &client_key);

let result = a & &b;
let result = result.decrypt(&client_key);
assert_eq!(result, true & true);

type Output = FheBool

The resulting type after applying the & operator.

impl BitAnd<FheBool> for bool

fn bitand(self, rhs: FheBool) -> Self::Output

Performs a bitwise ‘and’ between a bool and a FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = false & a;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, false & true);

type Output = FheBool

The resulting type after applying the & operator.

impl BitAnd<bool> for &FheBool

fn bitand(self, rhs: bool) -> Self::Output

Performs a bitwise ‘and’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = &a & false;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true & false);

type Output = FheBool

The resulting type after applying the & operator.

impl BitAnd<bool> for FheBool

fn bitand(self, rhs: bool) -> Self::Output

Performs a bitwise ‘and’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = a & false;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true & false);

type Output = FheBool

The resulting type after applying the & operator.

impl<B> BitAndAssign<B> for FheBool

where B: Borrow<Self>,

fn bitand_assign(&mut self, rhs: B)

Performs a bitwise ‘and’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheBool::encrypt(true, &client_key);
let b = true;

a &= b;
let result = a.decrypt(&client_key);
assert_eq!(result, true & true);

impl BitAndAssign<bool> for FheBool

fn bitand_assign(&mut self, rhs: bool)

Performs a bitwise ‘and’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheBool::encrypt(true, &client_key);

a &= false;
let result = a.decrypt(&client_key);
assert_eq!(result, true & false);

impl BitOr<&FheBool> for bool

fn bitor(self, rhs: &FheBool) -> Self::Output

Performs a bitwise ‘or’ between a bool and a FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = false | &a;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, false | true);

type Output = FheBool

The resulting type after applying the | operator.

impl<B> BitOr<B> for &FheBool

where B: Borrow<FheBool>,

fn bitor(self, rhs: B) -> Self::Output

Performs a bitwise ‘or’ between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(false, &client_key);

let result = &a | &b;
let result = result.decrypt(&client_key);
assert_eq!(result, true | false);

type Output = FheBool

The resulting type after applying the | operator.

impl<B> BitOr<B> for FheBool

where B: Borrow<Self>,

fn bitor(self, rhs: B) -> Self::Output

Performs a bitwise ‘or’ between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(false, &client_key);

let result = a | &b;
let result = result.decrypt(&client_key);
assert_eq!(result, true | false);

type Output = FheBool

The resulting type after applying the | operator.

impl BitOr<FheBool> for bool

fn bitor(self, rhs: FheBool) -> Self::Output

Performs a bitwise ‘or’ between a bool and a FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = false | a;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, false | true);

type Output = FheBool

The resulting type after applying the | operator.

impl BitOr<bool> for &FheBool

fn bitor(self, rhs: bool) -> Self::Output

Performs a bitwise ‘or’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = a | false;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true | false);

type Output = FheBool

The resulting type after applying the | operator.

impl BitOr<bool> for FheBool

fn bitor(self, rhs: bool) -> Self::Output

Performs a bitwise ‘or’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = a | false;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true | false);

type Output = FheBool

The resulting type after applying the | operator.

impl<B> BitOrAssign<B> for FheBool

where B: Borrow<Self>,

fn bitor_assign(&mut self, rhs: B)

Performs a bitwise ‘or’ between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(true, &client_key);

a |= &b;
let result = a.decrypt(&client_key);
assert_eq!(result, true | true);

impl BitOrAssign<bool> for FheBool

fn bitor_assign(&mut self, rhs: bool)

Performs a bitwise ‘or’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheBool::encrypt(true, &client_key);

a |= false;
let result = a.decrypt(&client_key);
assert_eq!(result, true | false);

impl BitXor<&FheBool> for bool

fn bitxor(self, rhs: &FheBool) -> Self::Output

Performs a bitwise ‘xor’ between a bool and a FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = false ^ &a;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, false ^ true);

type Output = FheBool

The resulting type after applying the ^ operator.

impl<B> BitXor<B> for &FheBool

where B: Borrow<FheBool>,

fn bitxor(self, rhs: B) -> Self::Output

Performs a bitwise ‘xor’ between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(true, &client_key);

let result = &a ^ &b;
let result = result.decrypt(&client_key);
assert_eq!(result, true ^ true);

type Output = FheBool

The resulting type after applying the ^ operator.

impl<B> BitXor<B> for FheBool

where B: Borrow<Self>,

fn bitxor(self, rhs: B) -> Self::Output

Performs a bitwise ‘xor’ between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(true, &client_key);

let result = a ^ &b;
let result = result.decrypt(&client_key);
assert_eq!(result, true ^ true);

type Output = FheBool

The resulting type after applying the ^ operator.

impl BitXor<FheBool> for bool

fn bitxor(self, rhs: FheBool) -> Self::Output

Performs a bitwise ‘xor’ between a bool and a FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = false ^ a;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, false ^ true);

type Output = FheBool

The resulting type after applying the ^ operator.

impl BitXor<bool> for &FheBool

fn bitxor(self, rhs: bool) -> Self::Output

Performs a bitwise ‘xor’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = a ^ false;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true ^ false);

type Output = FheBool

The resulting type after applying the ^ operator.

impl BitXor<bool> for FheBool

fn bitxor(self, rhs: bool) -> Self::Output

Performs a bitwise ‘xor’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = a ^ false;
let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true ^ false);

type Output = FheBool

The resulting type after applying the ^ operator.

impl<B> BitXorAssign<B> for FheBool

where B: Borrow<Self>,

fn bitxor_assign(&mut self, rhs: B)

Performs a bitwise ‘xor’ between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(true, &client_key);

a ^= &b;
let result = a.decrypt(&client_key);
assert_eq!(result, true ^ true);

impl BitXorAssign<bool> for FheBool

fn bitxor_assign(&mut self, rhs: bool)

Performs a bitwise ‘xor’ between FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheBool::encrypt(true, &client_key);

a ^= false;
let result = a.decrypt(&client_key);
assert_eq!(result, true ^ false);

impl<Id> CastFrom<FheBool> for FheInt<Id>

where Id: FheIntId,

fn cast_from(input: FheBool) -> Self

Cast a FheBool to a FheInt

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool, FheInt16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheInt16::cast_from(a);

let decrypted: i16 = b.decrypt(&client_key);
assert_eq!(decrypted, i16::from(true));

impl<Id> CastFrom<FheBool> for FheUint<Id>

where Id: FheUintId,

fn cast_from(input: FheBool) -> Self

Cast a boolean ciphertext to an unsigned ciphertext

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheUint16::cast_from(a);

let decrypted: u16 = b.decrypt(&client_key);
assert_eq!(decrypted, u16::from(true));

impl Clone for FheBool

fn clone(&self) -> FheBool

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for FheBool

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FheDecrypt<bool> for FheBool

fn decrypt(&self, key: &ClientKey) -> bool

Decrypts the value

impl<B> FheEq<B> for FheBool

where B: Borrow<Self>,

fn eq(&self, other: B) -> Self

Test for equality between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(false, &client_key);

let result = a.eq(&b);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true == false);

fn ne(&self, other: B) -> Self

Test for difference between two FheBool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);
let b = FheBool::encrypt(false, &client_key);

let result = a.ne(&b);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true != false);

impl FheEq<bool> for FheBool

fn eq(&self, other: bool) -> FheBool

Test for equality between a FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = a.eq(false);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true == false);

fn ne(&self, other: bool) -> FheBool

Test for equality between a FheBool and a bool

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = a.ne(false);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, true != false);

impl FheKeyswitch<FheBool> for KeySwitchingKey

fn keyswitch(&self, input: &FheBool) -> FheBool

impl FheTrivialEncrypt<bool> for FheBool

fn encrypt_trivial(value: bool) -> Self

Creates a trivial encryption of a bool.

Warning

Trivial encryptions are not real encryptions, as a trivially encrypted ciphertext can be decrypted by any key (in fact, no key is actually needed).

Trivial encryptions become real encrypted data once used in an operation that involves a real ciphertext

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt_trivial(true);

let decrypted: bool = a.decrypt(&client_key);
assert_eq!(decrypted, true);

impl FheTryEncrypt<bool, ClientKey> for FheBool

type Error = Error

fn try_encrypt(value: bool, key: &ClientKey) -> Result<Self, Self::Error>

impl FheTryEncrypt<bool, CompactPublicKey> for FheBool

type Error = Error

fn try_encrypt(value: bool, key: &CompactPublicKey) -> Result<Self, Self::Error>

impl FheTryEncrypt<bool, CompressedPublicKey> for FheBool

type Error = Error

fn try_encrypt( value: bool, key: &CompressedPublicKey ) -> Result<Self, Self::Error>

impl FheTryEncrypt<bool, PublicKey> for FheBool

type Error = Error

fn try_encrypt(value: bool, key: &PublicKey) -> Result<Self, Self::Error>

impl FheTryTrivialEncrypt<bool> for FheBool

type Error = Error

fn try_encrypt_trivial(value: bool) -> Result<Self, Self::Error>

impl<Id: FheIntId> IfThenElse<FheInt<Id>> for FheBool

fn if_then_else(&self, ct_then: &FheInt<Id>, ct_else: &FheInt<Id>) -> FheInt<Id>

Conditional selection.

The output value returned depends on the value of self.

• if self is true, the output will have the value of ct_then
• if self is false, the output will have the value of ct_else

fn cmux(&self, ct_then: &Ciphertext, ct_else: &Ciphertext) -> Ciphertext

impl<Id> IfThenElse<FheUint<Id>> for FheBool

where Id: FheUintId,

fn if_then_else( &self, ct_then: &FheUint<Id>, ct_else: &FheUint<Id> ) -> FheUint<Id>

Conditional selection.

The output value returned depends on the value of self.

• if self is true, the output will have the value of ct_then
• if self is false, the output will have the value of ct_else

fn cmux(&self, ct_then: &Ciphertext, ct_else: &Ciphertext) -> Ciphertext

impl Named for FheBool

const NAME: &'static str = "high_level_api::FheBool"

impl Not for &FheBool

fn not(self) -> Self::Output

Performs a bitwise ‘not’

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = !&a;
let result = result.decrypt(&client_key);
assert_eq!(result, false);

type Output = FheBool

The resulting type after applying the ! operator.

impl Not for FheBool

fn not(self) -> Self::Output

Performs a bitwise ‘not’

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheBool::encrypt(true, &client_key);

let result = !a;
let result = result.decrypt(&client_key);
assert_eq!(result, false);

type Output = FheBool

The resulting type after applying the ! operator.

impl ParameterSetConformant for FheBool

type ParameterSet = FheBoolConformanceParams

fn is_conformant(&self, params: &FheBoolConformanceParams) -> bool

impl Serialize for FheBool

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.