# [−][src]Struct turtle::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`

[src]

`pub fn instant() -> Self`

[src]

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`

[src]

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`

[src]

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

[src]

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

[src]

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`

[src]

`impl From<i32> for Speed`

[src]

`impl From<f64> for Speed`

[src]

`impl Clone for Speed`

[src]

`impl Copy for Speed`

[src]

`impl Eq for Speed`

[src]

`impl Ord for Speed`

[src]

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

[src]

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

1.21.0[src]

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

1.21.0[src]

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

[src]

`impl PartialEq<Speed> for Speed`

[src]

`impl PartialEq<i32> for Speed`

[src]

`impl PartialOrd<Speed> for Speed`

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

[src]

`impl PartialOrd<i32> for Speed`

[src]

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

[src]

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

1.0.0[src]

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

1.0.0[src]

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

1.0.0[src]

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

1.0.0[src]

`impl Debug for Speed`

[src]

`impl Display for Speed`

[src]

`impl Hash for Speed`

[src]

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

[src]

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

H: Hasher,

1.3.0[src]

H: Hasher,

`impl StructuralPartialEq for Speed`

[src]

`impl StructuralEq for Speed`

[src]

`impl Serialize for Speed`

[src]

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

__S: Serializer,

[src]

__S: Serializer,

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

[src]

`fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where`

__D: Deserializer<'de>,

[src]

__D: Deserializer<'de>,

## Auto Trait Implementations

`impl Send for Speed`

`impl Sync for Speed`

`impl Unpin for Speed`

`impl UnwindSafe for Speed`

`impl RefUnwindSafe for Speed`

## Blanket Implementations

`impl<T> From<T> for T`

[src]

`impl<T, U> Into<U> for T where`

U: From<T>,

[src]

U: From<T>,

`impl<T> ToOwned for T where`

T: Clone,

[src]

T: Clone,

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`

[src]

`fn clone_into(&self, target: &mut T)`

[src]

`impl<T> ToString for T where`

T: Display + ?Sized,

[src]

T: Display + ?Sized,

`impl<T, U> TryFrom<U> for T where`

U: Into<T>,

[src]

U: Into<T>,

`type Error = !`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

[src]

`impl<T, U> TryInto<U> for T where`

U: TryFrom<T>,

[src]

U: TryFrom<T>,

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

[src]

`impl<T> Borrow<T> for T where`

T: ?Sized,

[src]

T: ?Sized,

`impl<T> BorrowMut<T> for T where`

T: ?Sized,

[src]

T: ?Sized,

`fn borrow_mut(&mut self) -> &mut T`

[src]

`impl<T> Any for T where`

T: 'static + ?Sized,

[src]

T: 'static + ?Sized,

`impl<T> DeserializeOwned for T where`

T: Deserialize<'de>,

[src]

T: Deserialize<'de>,

`impl<T> SetParameter for T`

`fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where`

T: Parameter<Self>,

T: Parameter<Self>,