Enum CursorAffinity 

pub enum CursorAffinity {
    Forward,
    Backward,
}

Decides how the cursor should be placed around special areas of text.

Ex:

let j =            // soft linewrap
1 + 2 + 3;

where let j = has the issue that there’s two positions you might want your cursor to be: let j = | or |1 + 2 + 3;

These are the same offset in the text, but it feels more natural to have it move in a certain way. If you’re at let j =| and you press the right-arrow key, then it uses your backwards affinity to keep you on the line at let j = |.

If you’re at 1| + 2 + 3; and you press the left-arrow key, then it uses your forwards affinity to keep you on the line at |1 + 2 + 3;.

For other special text, like inlay hints, this can also apply.

let j<: String> = ...

where <: String> is our inlay hint, then

let |j<: String> = and you press the right-arrow key, then it uses your backwards affinity to keep you on the same side of the hint, let j|<: String>.

let j<: String> |= and you press the right-arrow key, then it uses your forwards affinity to keep you on the same side of the hint, let j<: String>| =.

Variants

Forward

<: String>|

Backward

|<: String>

Implementations

impl CursorAffinity

pub fn invert(&self) -> Self

Trait Implementations

impl Clone for CursorAffinity

fn clone(&self) -> CursorAffinity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CursorAffinity

impl Debug for CursorAffinity

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CursorAffinity

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for CursorAffinity

impl PartialEq for CursorAffinity

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CursorAffinity

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CursorAffinity