Enum CodeExecutionLanguage 

#[non_exhaustive]
pub enum CodeExecutionLanguage {
    Python,
    Unknown {
        language_type: String,
        data: Value,
    },
}

Programming language for code execution.

This enum represents the programming language used in code execution requests. Currently only Python is supported by the Gemini API.

Forward Compatibility (Evergreen Philosophy)

This enum is marked #[non_exhaustive], which means:

• Match statements must include a wildcard arm (_ => ...)
• New variants may be added in minor version updates without breaking your code

When the API returns a language value that this library doesn’t recognize, it will be captured as CodeExecutionLanguage::Unknown rather than causing a deserialization error. This follows the Evergreen spec philosophy of graceful degradation.

Example

if let Content::CodeExecutionCall { language, code, .. } = content {
    match language {
        CodeExecutionLanguage::Python => println!("Python code: {}", code),
        CodeExecutionLanguage::Unknown { language_type, .. } => {
            println!("Unknown language '{}': {}", language_type, code);
        }
        _ => println!("Other language: {}", code),
    }
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Python

Python programming language

Unknown

Unknown language (for forward compatibility).

This variant captures any unrecognized language values from the API, allowing the library to handle new languages gracefully.

The language_type field contains the unrecognized language string, and data contains the full JSON value for debugging.

Fields

language_type: String

The unrecognized language string from the API

data: Value

The raw JSON value, preserved for debugging

Implementations

impl CodeExecutionLanguage

pub const fn is_unknown(&self) -> bool

Check if this is an unknown language.

pub fn unknown_language_type(&self) -> Option<&str>

Returns the language type name if this is an unknown language.

Returns None for known languages.

pub fn unknown_data(&self) -> Option<&Value>

Returns the raw JSON data if this is an unknown language.

Returns None for known languages.

Trait Implementations

impl Clone for CodeExecutionLanguage

fn clone(&self) -> CodeExecutionLanguage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CodeExecutionLanguage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CodeExecutionLanguage

fn default() -> CodeExecutionLanguage

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CodeExecutionLanguage

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CodeExecutionLanguage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for CodeExecutionLanguage

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CodeExecutionLanguage

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CodeExecutionLanguage

impl StructuralPartialEq for CodeExecutionLanguage