Struct turtle::Speed

pub struct Speed(_);

Represents both the movement and rotation speed of the turtle.

Creating Speeds

You can create a Speed value by converting either strings or numbers.

// This value is of type `Speed` and it is converted from an `i32`
let speed: Speed = 1.into();

// This value is of type `Speed` and it is converted from a `&str`
let slowest_speed: Speed = "slowest".into();

There is no need to call .into() when passing a speed into the set_speed method. See the set_speed method for more information about how that works.

let mut turtle = Turtle::new();
turtle.set_speed(22); // Same as `turtle.set_speed(22.into())`

The minimum speed value is 1 and the maximum speed value (currently) is 25.

Trying to set the speed to a value out of that range will cause a panic.

let mut turtle = Turtle::new();
turtle.set_speed(26); // panic!

While the minimum speed will not change, the maximum speed may grow larger if the need arises. That is why we chose to panic for invalid speeds instead of defaulting to another value.

String Conversion

Strings are converted as follows:

String	Value
"slowest"	1
"slower"	5
"slow"	8
"normal"	10
"fast"	12
"faster"	15
"instant"	see below

You can use strings to create Speed values in the same way numbers were used above. Each of the following is an equivalent way to set the speed to 5:

turtle.set_speed(5);
turtle.set_speed("slower");
turtle.set_speed(Speed::from(5)); // Not recommended!
turtle.set_speed(Speed::from("slower")); // Not recommended!

Instant

There is one special speed value "instant" which makes it so that movement and rotation are not animated at all. Instead, the turtle immediately moves and rotates to the position that you directed it to. It will still draw along the way if its pen is down.

let mut turtle = Turtle::new();
turtle.set_speed("instant");
turtle.forward(100.0); // A line will be drawn instantly!

Comparing Speed Values

Speed values can be compared for equality with i32 values. This is a little more convenient than converting the i32 to Speed every time you want to make a comparison.

let speed: Speed = 1.into();
// Speed values can be compared to integers
assert_eq!(speed, 1);
// This is equivalent to the following
assert_eq!(speed, Speed::from(1));

// This value is of type `Speed` and it is converted from a `&str`
let speed: Speed = "slowest".into();
// Speed values can be compared to other speed values
assert_eq!(speed, Speed::from("slowest"));
// This is equivalent to the following since the slowest speed is 1
assert_eq!(speed, 1);

You can use the <, <=, ==, >=, > with Speed values and i32 values (or other Speed values).

let turtle = Turtle::new();
let speed = turtle.speed();
if speed == 12 && speed >= 5 && speed < Speed::instant() {
    println!("Super fast!!");
}
// This is equivalent, but requires more typing
if speed == Speed::from(12) && speed >= Speed::from(5) && speed < Speed::from("instant") {
    println!("Super fast!!");
}

Notice that you can compare Speed values to numeric values, but not the other way around.

let speed: Speed = 7.into();
if 8 > speed { // This doesn't make sense and won't compile!
    // ...
}

To check if a speed is instant, use the is_instant() method or compare the speed to Speed::instant().

let speed = Speed::instant();
if speed.is_instant() {
    println!("Instant!!");
}

Methods

impl Speed

pub fn instant() -> Self

Returns the speed value that will make the turtle move and rotate instantly. This means that instead of the turtle's movements being animated, it will directly move to wherever you direct it to go.

let mut turtle = Turtle::new();
turtle.set_speed(Speed::instant());
turtle.forward(100.0); // A line will be drawn instantly!

Whenever possible, you should prefer to use the string "instant" instead of calling this method.

turtle.set_speed("instant"); // equivalent to typing `Speed::instant()`

pub fn is_instant(self) -> bool

Returns true if this speed is the same as Speed::instant()

use turtle::{Speed};
let speed: Speed = "instant".into();
assert!(speed.is_instant());

let speed = Speed::instant();
assert!(speed.is_instant());

Trait Implementations

impl Random for Speed

fn random() -> Self

Generates a random speed within the valid range of speed levels

impl<B: Into<Speed>> RandomRange<B> for Speed

fn random_range(low: B, high: B) -> Self

Generates a random difficulty level within the given range, not including instant.

Panics

Panics if either bound could result in a value outside the valid range of speed levels or if low > high. Also panics if either bound is Speed::instant().

impl<'a> From<&'a str> for Speed

fn from(s: &'a str) -> Self

Performs the conversion.

impl From<i32> for Speed

fn from(n: i32) -> Self

Performs the conversion.

impl From<f64> for Speed

fn from(n: f64) -> Self

Performs the conversion.

impl Clone for Speed

fn clone(&self) -> Speed

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Speed

impl Eq for Speed

impl Ord for Speed

fn cmp(&self, other: &Speed) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<Speed> for Speed

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialEq<i32> for Speed

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<Speed> for Speed

fn partial_cmp(&self, other: &Speed) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Speed) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Speed) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Speed) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Speed) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i32> for Speed

fn partial_cmp(&self, other: &i32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Debug for Speed

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

Formats the value using the given formatter.

impl Display for Speed

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

Formats the value using the given formatter.

impl Hash for Speed

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl StructuralPartialEq for Speed

impl StructuralEq for Speed

impl Serialize for Speed

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

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for Speed

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.