Rust - Generic Traits

Rust - Generics

Last Updated : 08 Sep, 2022

Generics in Rust is a method of generalizing data types. Generics are always defined at run time. As generics can have multiple forms over given parameters and can be applied to methods, functions, structures, traits, etc they are often referred to as parametric polymorphism in type theory. Generics allow writing clean and concise code thereby providing type safety and refactored code.

In Generics, we have <T> as the type parameter which is used to declare a generic construct T. T can be of any data type.

Now we see an example for generic collections, we create a vector that has an integer of i32 type.

Example 1:

Rust

fn main(){
   let mut _int_vector: Vec<i32> = vec![10,20]; 
   // initializing integer vectors
   _int_vector.push(30); 
   // integer number is pushed to a vector
   println!("{:?}",_int_vector); 
   
}

Output:

The <T> type indicates the generic type specifier for the Data.

Example 2:

Rust

// Generic Struct in RUST
struct Data<T> {
   value:T,
}
fn main() {
   // generic type of String
   let type1:Data<String> = Data{value:"GFG".to_string()};
   println!("Organization :{} ",type1.value);
   // generic type of i32
   let type2:Data<i32> = Data{value:2022};
   println!("Year :{} ",type2.value);
}

Output:

Here, the merge function takes a value of the string as well as takes a value of i32. T is the generic type specifier.

Example 3:

Rust

//  Generic Functions in RUST
fn main(){
   println!("****** Passing String literals*******"); 
   merge("Geeks for ", " Geeks "); 
   println!("******** Passing an integer ***********"); 
   merge(20 as i32, 22 as i32);
   
}
use std::fmt::Display;
fn merge<T:Display>(t:T, s:T){
   let result = format!("{}{}", t , s);
   println!("{}", result);
}

Output:

Rust - Generic Traits

S

sayanc170

Improve

Article Tags :

Similar Reads

Rust - Generic Traits

Rust is an extremely fast programming language that supports speed, concurrency, as well as multithreading. In Rust, we have a concept of Generic Traits where Generics are basically an abstraction of various properties, and Traits are basically used for combining generic types for constraining types

Rust - Generic Function

In Rust, Generic functions are very useful. Generic make code more flexible and provide more functionality to the callers of the function. It prevents code duplication as it is not required to define different functions of different types. Generics are specified in the signature of function where we

Kotlin generics

Generics are the powerful features that allow us to define classes, methods and properties which are accessible using different data types while keeping a check on the compile-time type safety. Creating parameterized classes - A generic type is a class or method that is parameterized over types. We

Rust - Interface

Rust is a systems programming language with a concept of Interfaces in Rust that is implemented by Traits.Trait in Rust is basically a struct having no bodies for the methods. The logic is generally not defined but only the methods are. Rust enforces us to follow a set of coding practices with imple

Rust - Dependencies

In Rust, Â there are situations where we encounter situations where there is a dependency on other libraries. The rust ecosystem has a solution to it by having Cargo as its package manager that eases managing dependencies in almost all situations efficiently. Syntax:For creating a new library, we use

An enum in Rust is a custom data type that represents data that can be anyone among several possible variants. Each variant in the enum can optionally have data associated with it. An enumerated type is defined using the enum keyword before the name of the enumeration. It also consists of methods. S

Rust - Literals

A literal is a source code that represents a fixed value and can be represented in the code without the need for computation. The compiler uses by default i32 for integers and f64 for float types/. In Rust, literals are described by adding them in the type as a suffix.Â Example: Â Integer literal 6 h

Dart - Generics

In Dart, by default collections are heterogeneous. However, by the use of generics, we can make a collection to hold homogeneous values. The use of Generics makes the use of a single compulsory data type to be held inside the collection. Such collections are called type-safe collections. By the use

Rust - Conventions

In Rust, there are certain conventions that need to be followed when we are creating dependencies. There are dependencies on libraries in Rust. Cargo! is a dependency manager in Rust that is similar to npm (in JavaScript) and pip (in Python). All the project dependencies are handled by cargo. For in

Rust - Comments

In Rust programming, a comment is a programmer-readable explanation or annotation in the source code of a computer program. Comments are statements that are not executed by the compiler and interpreter. To write comments in Rust, we have two types of comments as in any other programming language. No