Trait Bounds

Now that we know a bit about traits and generics, let's dive into trait bounds. Trait bounds allow you to specify that a generic type must implement a particular trait. This ensures that only types with certain capabilities can be used with your generic code.

For example:

A generic function can be constrained to types that implement the std::fmt::Display trait for printing.
A generic struct can be limited to types that implement traits like PartialOrd for comparison.

Trait bounds make your code flexible while maintaining strong type safety.

Syntax

You can specify trait bounds in two ways:

Inline: Specify the trait bounds after the impl or fn keyword.

fn my_function<T: Trait1 + Trait2>(value: T) {
    // code here
}

Where clause: Use a where clause to specify trait bounds.

fn my_function<T>(value: T)
where
     T: Trait1 + Trait2,
{
     // code here
}

This means that the generic type T must implement both Trait1 and Trait2.

Your Task

Define a generic function compare_and_display that:
- Takes two parameters of the same type.
- Prints both parameters using the Display trait.
- Returns the greater of the two using the PartialOrd trait.
Use trait bounds to ensure the function works only with types that implement both Display and PartialOrd.

Hints

If you're stuck, here are some hints to help you solve the challenge:

Click here to reveal hints

Use std::cmp::PartialOrd to compare values.
Use std::fmt::Display to print values with the println! macro.
You can write trait bounds inline with T: Trait1 + Trait2 or using a where clause. e.g.
```
fn my_function<T: Trait1 + Trait2>(value: T) {
    // code here
}
```

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Snoweuph

snoweuph

44 minutes ago

3.35ms

88.22kb

use std::fmt::Display;
pub fn compare_and_display<T>(a: T, b: T) -> T
where
    T: PartialOrd + Display,
{
    println!("a: {a} b: {b}");
    if a > b {
        a
    } else {
        b
    }
}

Snoweuph

snoweuph

44 minutes ago

3.42ms

88.22kb

use std::fmt::Display;
pub fn compare_and_display<T>(a: T, b: T) -> T
where
    T: PartialOrd + Display,
{
    println!("a: {a} b: {b}");
    if a > b {
        a
    } else {
        b
    }
}
pub fn main() {
    let greater = compare_and_display(10, 20);
    println!("Greater value: {}", greater);
    let greater = compare_and_display("Apple", "Orange");
    println!("Greater value: {}", greater);
}

azmahflameheart

a day ago

3.40ms

87.94kb

use std::{fmt::Display, cmp::PartialOrd};
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: Display + PartialOrd>(a: T, b: T) -> T { // Complete the function definition
     if a > b { a } else { b }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Marouan Boulahtouf

MBoulahtouf

a day ago

3.51ms

87.45kb

use std::{fmt::Display, cmp::PartialOrd};
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: PartialOrd + Display>(a: T, b: T) -> T {
     if a < b {
          println!("{0} < {1}", a, b);
          b
     } else {
          a
     }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

ffrie

3 days ago

3.71ms

88.11kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: std::fmt::Display + PartialOrd>(a: T, b: T) -> T {
     println!("{}", a);
     println!("{}", b);
     if a > b {
          a
     } else {
          b
     }
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

vqk-2003

4 days ago

3.50ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T>(arg1: T, arg2: T) -> T
where
     T: std::fmt::Display + PartialOrd,
{
     if arg1 > arg2 { arg1 } else { arg2 }
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

gtakacse

5 days ago

3.51ms

88.43kb

use std::fmt::Display;
pub fn compare_and_display<T>(a: T, b: T) -> T
where
    T: Display + PartialOrd,
{
    println!("Comparing {} and {}.", a, b);
    if a > b {
        a
    } else {
        b
    }
}
// Example usage
pub fn main() {
    let greater = compare_and_display(10, 20);
    println!("Greater value: {}", greater);
    let greater = compare_and_display("Apple", "Orange");
    println!("Greater value: {}", greater);
}

LawisChen

5 days ago

3.31ms

87.94kb

use std::fmt::Display;
pub fn compare_and_display<T>(a: T, b: T) -> T
where
    T: Display + PartialOrd,
{
    if a >= b { a } else { b }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Ramon Silva

rsilva1

7 days ago

3.38ms

88.18kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
// Complete the function definition
use std::fmt::Display;
pub fn compare_and_display<T>(a: T, b: T) -> T
where
     T: Display + PartialOrd
{
     println!("{} {}", a, b);
     if a > b {
          a
     } else {
          b
     }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

ychanghe

8 days ago

3.64ms

88.16kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T>(a:T, b:T)  -> T
where 
     T: std::fmt::Display + std::cmp::PartialOrd, 
{
     println!("{}{}", a, b);
     if a>b {
          a
     }
     else { b }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

makinpaper

9 days ago

4.33ms

87.94kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: Display + PartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
} // Complete the function definition
// Example usage
pub fn main() {
    let greater = compare_and_display(10, 20);
    println!("Greater value: {}", greater);
    let greater = compare_and_display("Apple", "Orange");
    println!("Greater value: {}", greater);
}

fasolyee

fasolyeedev

11 days ago

4.33ms

88.16kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
// Complete the function definition
use std::fmt::Display;
pub fn compare_and_display<T: Display + PartialOrd>(item1: T, item2 :T) -> T {
     println!("{}{}",item1,item2);
     if item1 > item2{
          item1
     }
     else{
          item2
     }
} 
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

<YoungAncient/>

youngancient

11 days ago

3.83ms

88.11kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: Display + PartialOrd>(para_1 : T, para_2 : T) -> T{
     println!("{}",para_1);
     println!("{}",para_2);
     if para_1 > para_2{
          return para_1;
     }else{
          return para_2;
     }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Dan Wayne

danwayne-me

11 days ago

3.59ms

87.94kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: PartialOrd + Display>(left: T, right: T) -> T {
     if left < right { right } else {left}
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Omar Saber Talaat Abdelrahman

omar-s-ta

11 days ago

4.80ms

87.96kb

use std::fmt::Display;
pub fn _compare_and_display<T>(a: T, b: T) -> T
where
    T: std::fmt::Display + PartialOrd,
{
    if a > b {
        println!("{} {}", a, b);
        a
    } else {
        b
    }
}
pub fn compare_and_display<T: Display + PartialOrd>(a: T, b: T) -> T {
    if a > b {
        println!("{} {}", a, b);
        a
    } else {
        b
    }
}
pub fn main() {
    let greater = compare_and_display(10, 20);
    println!("Greater value: {}", greater);
    let greater = compare_and_display("Apple", "Orange");
    println!("Greater value: {}", greater);
}

Omar Saber Talaat Abdelrahman

omar-s-ta

11 days ago

3.55ms

87.96kb

pub fn _compare_and_display<T>(a: T, b: T) -> T
where
    T: std::fmt::Display + PartialOrd,
{
    if a > b {
        println!("{} {}", a, b);
        a
    } else {
        b
    }
}
pub fn compare_and_display<T: std::fmt::Display + PartialOrd>(a: T, b: T) -> T {
    if a > b {
        println!("{} {}", a, b);
        a
    } else {
        b
    }
}
pub fn main() {
    let greater = compare_and_display(10, 20);
    println!("Greater value: {}", greater);
    let greater = compare_and_display("Apple", "Orange");
    println!("Greater value: {}", greater);
}

Omar Saber Talaat Abdelrahman

omar-s-ta

11 days ago

3.42ms

87.96kb

pub fn compare_and_display<T>(a: T, b: T) -> T
where
    T: std::fmt::Display + PartialOrd,
{
    if a > b {
        println!("{} {}", a, b);
        a
    } else {
        b
    }
}
pub fn main() {
    let greater = compare_and_display(10, 20);
    println!("Greater value: {}", greater);
    let greater = compare_and_display("Apple", "Orange");
    println!("Greater value: {}", greater);
}

Omar Saber Talaat Abdelrahman

omar-s-ta

11 days ago

3.57ms

87.94kb

pub fn compare_and_display<T>(a: T, b: T) -> T
where
    T: std::fmt::Display + PartialOrd,
{
    if a.gt(&b) {
        a
    } else {
        b
    }
}
// Example usage
pub fn main() {
    let greater = compare_and_display(10, 20);
    println!("Greater value: {}", greater);
    let greater = compare_and_display("Apple", "Orange");
    println!("Greater value: {}", greater);
}

Ignat S.

Igonato

12 days ago

3.20ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: PartialOrd + std::fmt::Display>(a: T, b: T) -> T {
     if a > b {
          a
     } else {
          b
     }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

SpontaneousOverthrow

13 days ago

4.53ms

88.18kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
use std::fmt;
pub fn compare_and_display<T>(x: T, y:T) -> T
where
     T: fmt::Display + PartialOrd,
{
     println!("{} {}", x, y);
     if x > y {
          return x
     } else {
          return y
     }
     
}// Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

MöNir

Monir-Ruet

18 days ago

3.32ms

87.94kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T>(a: T, b: T) -> T
where
    T: Display + PartialOrd,
{
    if a > b { a } else { b }
}
// Example usage
pub fn main() {
    let greater = compare_and_display(10, 20);
    println!("Greater value: {}", greater);
    let greater = compare_and_display("Apple", "Orange");
    println!("Greater value: {}", greater);
}

0xdangit

18 days ago

3.73ms

88.11kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
use std::fmt::Display;
pub fn compare_and_display<T>(param1: T, param2: T) -> T 
where T: Display + PartialOrd 
{
     println!("{}", param1);
     println!("{}", param2);
     if param1 > param2 {
          return param1;
     }
     else {
          return param2;
     }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Dimas Avrian Fachriza

FForFachriza

18 days ago

6.64ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: PartialOrd>(x:T, y: T)->T{
     if x>y  {
          x
     }else{
          y
     }
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Asrul Firdaus

AsrulF

20 days ago

4.28ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: std::fmt::Display + PartialOrd>(type1: T, type2: T) -> T {
     if type1 > type2 {
          type1
     } else {
          type2
     }
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

yrd241

20 days ago

3.32ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T:PartialOrd>(value1: T, value2: T) -> T
     {
          if value1 > value2 {
               value1
          } else {
               value2
          }
     }
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Dharm Singh

dharmvr1

21 days ago

3.82ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: PartialOrd >(v1: T, v2: T) -> T {
    if v1 > v2 {
        v1
    } else {
        v2
    }
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

kasaxpong

21 days ago

3.59ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T:std::cmp::PartialOrd>(a:T, b:T) -> T { // Complete the function definition
if a > b {
     return a;
} else {
     return b;
} 
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

noname

random1106

22 days ago

5.29ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T:std::cmp::PartialOrd>(a:T, b:T ) -> T {
     if a > b {
          return a;
     } else {
          return b;
     }
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Lucas Sorensen

lucasalexsorensen

22 days ago

3.71ms

88.19kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: std::fmt::Display + std::cmp::PartialOrd>(a: T, b: T) -> T {
     println!("a={} b={}", &a, &b);
     if a > b {
          return a;
     }
     b
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Mykhailo Huzhvii

Ymkavi

24 days ago

3.60ms

88.11kb

use core::fmt::Display;
pub fn compare_and_display<T: Display + PartialOrd>(a: T, b: T) -> T {
     println!("{}", a.to_string());
     println!("{}", b.to_string());
     if a > b {
          a
     }
     else {
          b
     }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Bastien VINH

bastienvinh

a month ago

3.72ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T>(a: T, b: T) -> T where T: PartialOrd + std::fmt::Display {
     if a > b { a } else { b }
}  // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

hidethere

a month ago

4.65ms

88.11kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
use std::fmt::Display;
pub fn compare_and_display<T: Display + PartialOrd>(a:T, b:T) -> T {
     println!("{}", a);
     println!("{}", b);
     if a > b {
          a
     } else {
          b
     }
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

银雀Sparrxw

Sparr0www820

a month ago

6.77ms

87.94kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T>(a: T, b: T) -> T
where
     T: Display + PartialOrd,
{
     if a > b { a } else { b }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Kishan

wdcs-kishansudani

a month ago

3.89ms

87.94kb

use core::fmt::Display;
pub fn compare_and_display<T>(param_a: T, param_b: T) -> T
where
     T: Display + PartialOrd,
{
     if param_a > param_b {
          param_a
     } else {
          param_b
     }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Dr. Frederik Lauber

FrederikLauber

a month ago

3.86ms

88.11kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: Display + PartialOrd>(a: T, b:T) -> T{
     println!("{}", a);
     println!("{}", b);
     if a > b {
          a
     } else {
          b
     }
} 
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

/sam

samging

a month ago

3.66ms

87.89kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: Display + PartialOrd>(a:T,b:T)->T{
     if a > b {
        println!("{} > {}", a, b);
        a
    } else {
        b
    }
} 
// Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

/sam

samging

a month ago

4.37ms

87.89kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: Display + PartialOrd>(a:T,b:T)->T{
     if a > b {
        println!("{} > {}", a, b);
        a
    } else {
        b
    }
} 
// Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Ari Karim

arikarim

a month ago

4.37ms

88.19kb

use std::fmt::Display;
pub fn compare_and_display<T>(a: T, b: T) -> T
where
    T: Display + PartialOrd,
 {
    println!("{}, {}", a, b);
    if a > b {
        a
    } else {
        b
    }
 }
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Yummy-Yums

a month ago

4.69ms

87.45kb

use std::cmp::PartialOrd;
use std::fmt::Display;
pub fn compare_and_display<T: PartialOrd + Display>(arg1: T, arg2: T) -> T {
    if arg1 < arg2 {
        println!("{} < {}", arg1, arg2);
        arg2
    } else {
        arg1
    }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Yashwanth

Yash981

a month ago

7.25ms

87.94kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
use std::cmp::PartialOrd;
use std::fmt::Display;
pub fn compare_and_display<T:PartialOrd + Display>(a:T,b:T)->T{
     if a > b{
          a
     } else {
          b
     }
} 
// Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

xexid84

a month ago

4.63ms

88.11kb

use std::fmt::Display;
use std::cmp::PartialOrd;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T>(a: T, b: T) -> T
where T: Display + PartialOrd
{
     println!("{a}");
     println!("{b}");
     if a > b {a} else {b}
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Zisraw

a month ago

4.06ms

88.18kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: Display + PartialOrd>(p1: T, p2: T) -> T{
     println!("{} {}", p1, p2);
     if p1>p2 {
          p1
     }
     else{
          p2
     }
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

SubZ69

a month ago

6.25ms

88.18kb

use std::fmt::Display;
pub fn compare_and_display<T>(left: T, right: T) -> T
     where
          T: Display + PartialOrd,
     {
          println!("{left} {right}");
          if left > right { left } else { right }
     }
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Vincent SAMY

vsamy

a month ago

3.33ms

88.38kb

use std::fmt::Display;
use std::cmp::PartialOrd;
pub fn compare_and_display<T: Display + PartialOrd>(arg1: T, arg2: T) -> T {
     print!("Item1: {}. Item2: {}", arg1, arg2);
     if arg1 < arg2 {
          arg2
     } else {
          arg1
     }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

reborn3d

a month ago

4.20ms

88.41kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T>( item : T, item2 : T) -> T // Complete the function definition
where T: std::fmt::Display + std::cmp::PartialOrd, {
     println!("Item 1:{} , Item 2:{}", item,item2);
     if item > item2 {
          return item;
     }
     else {
          return item2;
     }
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

jfloresremar

a month ago

3.67ms

88.62kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T>(a: T, b: T) -> T
where
    T: Display + PartialOrd,
{
    println!("parameter 1: {a}");
    println!("parameter 2: {b}");
    if a > b {
        a
    } else {
        b
    }
}
// Example usage
pub fn main() {
    let greater = compare_and_display(10, 20);
    println!("Greater value: {}", greater);
    let greater = compare_and_display("Apple", "Orange");
    println!("Greater value: {}", greater);
}

Abhishek Sharma

0xAbhiDev

a month ago

3.77ms

88.48kb

// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display <T : Display + PartialOrd> (value1 :T, value2 :T) -> T{
println!("Value1 : {} , Value2 : {}", value1, value2);
if value1 > value2 {
return  value1 ;
}
value2
} // Complete the function definition
use std::fmt::Display;
use std::cmp::PartialOrd;
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

nojae15

2 months ago

3.62ms

87.94kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: Display + PartialOrd>(a: T, b :T) -> T{
     if a>b{
          return a
     } 
     b 
} // Complete the function definition
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

Francisco Alejandro

francisco-alejandro

2 months ago

3.60ms

88.18kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T>(a:T, b:T) -> T where T:Display + PartialOrd {
     println!("{} {}", a, b);
     if a > b {
          return a;
     }
     b
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}

SAMUEL-NOVAK

2 months ago

5.04ms

88.18kb

use std::fmt::Display;
// TODO: Define the generic function `compare_and_display` with appropriate trait bounds.
pub fn compare_and_display<T: Display + PartialOrd>(value1: T, value2: T) -> T{
     println!("{} {}", value1, value2);
     if value1 > value2 {
          return value1;
     }
     value2
}
// Example usage
pub fn main() {
     let greater = compare_and_display(10, 20);
     println!("Greater value: {}", greater);
     let greater = compare_and_display("Apple", "Orange");
     println!("Greater value: {}", greater);
}