Functions in Rust

Primitive Compound Datatypes in Rust

Last Updated : 03 Dec, 2021

Rust programming language has a concept of compound data types which collections that can group multiple types into one. In simple words, compound Datatypes are data structures that can hold multiple data elements in a single variable (or) reference. There are two primitive compound types in Rust:

Arrays
Tuples

The Tuple Type:

A tuple in Rust is a finite heterogeneous compound data type, meaning it can store more than one value at once. In tuples there is no inbuilt method to add elements into a tuple. We can use index to get the value of a tuple, and we also can not iterate over a tuple using for loop, unlike arrays which are mutable, meaning once declared they cannot grow or shrink.

Example:

Rust

fn main() { 
    
    // creating tuple 
    let gfg: (&str, &str, &str) = ("Geeks", "For", "Geeks"); 
  
    // accessing tuple data using positional argument 
    println!("{} {} {}", gfg.0, gfg.1, gfg.2); 
  
    // creating another tuple 
    let article = ("geeksforgeeks", "kushwanthreddy", 14,12,2020); 
    let (a,b,c,d,e) = article; 
  
    // accessing tuple using variables 
    println!("This article is written by {} at {} on {}/{}/{}", b,a,c,d,e); 
}

Output:

Geeks For Geeks
This article is written by kushwanthreddy at geeksforgeeks on 14/12/2020

The Array Type:

Arrays are the same as tuples but the difference is that Arrays can have multiple values of the same data type whereas tuples can have multiple values of multiple data types. Arrays in Rust are different from arrays in some other languages because arrays in Rust have a fixed length, like tuples. the array are written as a comma-separated list inside square brackets.

Example:

Rust

fn main() { 
    
    // creating array 
    let gfg = ["Geeks", "For", "Geeks"]; 
  
    // accessing array data using positional argument 
    println!("{} {} {}", gfg[0], gfg[1], gfg[2]); 
}

Output:

Geeks For Geeks

In many low-level languages when you provide an incorrect index, invalid memory can be accessed. Rust protects you against this kind of error by immediately exiting instead of allowing memory access and continuing.

Functions in Rust

kushwanthreddy

Improve

Article Tags :

Similar Reads

Scalar Datatypes in Rust

All initialized variables use data-type during declaration to restrict the type of data to be stored. Therefore, we can say that data types are used to tell the variables the type of data they can store. In this article, we will specifically talk about the Scalar Data types in the Rust programming l

Rust - Multiple Bounds

In Rust, we have a concept of multiple bounds. Multiple bounds are defined under the Traits of Rust programming. Multiple bounds in Rust can be applied with a '+' operator and the types are separated using comma (,) For needing more than one bounds in Rust programs, we need to import use::std::fmt::

Conditionals in Rust

Conditional Statements are the decision-making statements based on given conditions. Conditional statements are common in programming languages and rust has them and unlike many of them, the boolean condition doesn't need to be surrounded by parentheses but is better to use, and each condition is fo

Rust - Concept of Data Freezing

Rust is a systems programming language. In Rust, there is a concept of freezing which states that whenever data is borrowed, the borrowed data is also frozen. This frozen data cannot be modified until the references get out of scope i.e. all the bindings go out of scope. Suppose in the given below e

Rust - Closure as an Input Parameter

In Rust, Closures can be taken as input for the parameters. Closures are functions that wrap up functions for reusable purposes, which help capture variables in the enclosing environment. Closures are closed over when used in functions and for a single expression elimination ({ }) is used. The closu

Rust lifetime Constructor

In Rust, we have a concept of a lifetime constructor that falls under the ownership category. Rust enforces a certain set of rules through its concept of ownership and lifetimes. In this article, we would be learning more about Lifetimes in Rust. In Rust, there are various regions that are present i

Rust - Constants

Constants are the value that can not be changed after assigning them. If we created a constant, then there is no way of changing its value. The keyword for declaring constant is const. In Rust, constants must be explicitly typed. The below syntax is used to initialize a constant value: Syntax : cons

Rust - Reference Counted Smart Pointer

In Rust, there is a concept of a Smart pointer where we use multiple ownership explicitly using the Rc<T> type. This Rc <type> is referred to as Reference counting. This concept was introduced in Rust to handle scenarios where a single value of the variable has multiple owners. Rc<T

Rust - Functions With Closure as Parameter

In Rust, there are anonymous functions that accept closure as parameters. In closures, we are generally not required to annotate types of parameters or return values as opposed to functions. Closures are stored in variables and are used without requiring to name them and exposing them to users of th

Rust - Concept of Ownership

Rust programming language is known for its memory management. This article explains how Rust uses its Ownership model for better memory management. If you want to have a recap of Rust syntax before getting on this article you can refer to the Rust Archives. Generally, there are 2 ways to manage memo