Skip to main content

Word

rust_lstar::word

Struct Word 

Source 
pub struct Word { /* private fields */ }
Expand description

Represents a word - a sequence of letters

Implementations§

Source§

impl Word

Source

pub fn new() -> Self

Create a new empty word

Examples found in repository?
examples/memory_kb.rs (line 63)
61    fn submit_word_to_target(&mut self, word: &Word) -> Result<Word, String> {
62        if word.is_empty() {
63            return Ok(Word::new());
64        }
65
66        let initial_state = self.target.initial_state.clone();
67        let (output_word, _) = self
68            .target
69            .play_word(word, Some(&initial_state))?;
70        Ok(output_word)
71    }
Source

pub fn from_letters(letters: Vec<Letter>) -> Self

Create a word from a vector of letters

Examples found in repository?
examples/all_eqtests_custom_kb.rs (line 224)
208    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
209        self.stats.increment_nb_query();
210        self.stats.add_nb_letter(query.input_word.len());
211        self.stats.increment_nb_submitted_query();
212        self.stats.add_nb_submitted_letter(query.input_word.len());
213
214        self.state = ATMState::Idle;
215        let mut outputs = Vec::new();
216
217        for input_letter in query.input_word.letters() {
218            let command = input_letter.symbols();
219            let (next_state, response) = self.process_input(command.as_str(), self.state);
220            self.state = next_state;
221            outputs.push(Letter::new(response));
222        }
223
224        query.set_result(Word::from_letters(outputs));
225        Ok(())
226    }
More examples
Hide additional examples
examples/vending_machine.rs (line 94)
75    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
76        self.stats.increment_nb_query();
77        self.stats.add_nb_letter(query.input_word.len());
78        self.stats.increment_nb_submitted_query();
79        self.stats.add_nb_submitted_letter(query.input_word.len());
80
81        // Reset to initial state for each query
82        self.state = VendingState::Idle;
83
84        let mut outputs = Vec::new();
85        for input_letter in query.input_word.letters() {
86            let command_string = input_letter.symbols();
87            let command = command_string.as_str();
88
89            let (next, resp) = self.process_input(command, self.state);
90            self.state = next;
91            outputs.push(Letter::new(resp));
92        }
93
94        query.set_result(Word::from_letters(outputs));
95        Ok(())
96    }
examples/custom_kb.rs (line 115)
94    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
95        self.stats.increment_nb_query();
96        self.stats.add_nb_letter(query.input_word.len());
97        self.stats.increment_nb_submitted_query();
98        self.stats.add_nb_submitted_letter(query.input_word.len());
99        // Reset to initial state for each query
100        self.state = ATMState::Idle;
101
102        // let mut state = self.state.lock().unwrap();
103        let mut outputs = Vec::new();
104
105        for input_letter in query.input_word.letters() {
106            // Extract command from letter name (format: "Letter('x')")
107            let symbol = input_letter.symbols();
108            let command = symbol.as_str();
109
110            let (next_state, response) = self.process_input(command, self.state);
111            self.state = next_state;
112            outputs.push(Letter::new(response));
113        }
114
115        query.set_result(Word::from_letters(outputs));
116        Ok(())
117    }
examples/benchmark.rs (line 111)
89    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
90        self.stats.increment_nb_query();
91        self.stats.add_nb_letter(query.input_word.len());
92        self.stats.increment_nb_submitted_query();
93        self.stats.add_nb_submitted_letter(query.input_word.len());
94
95        self.current_state = "s0".to_string();
96        let mut output_letters = Vec::new();
97
98        for input_letter in query.input_word.letters() {
99            let input = input_letter.symbols();
100            let key = (self.current_state.clone(), input);
101            let (output, next_state) = self
102                .transitions
103                .get(&key)
104                .cloned()
105                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
106
107            output_letters.push(Letter::new(output));
108            self.current_state = next_state;
109        }
110
111        query.set_result(Word::from_letters(output_letters));
112        Ok(())
113    }
examples/random_walk_eq.rs (line 120)
98    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
99        self.stats.increment_nb_query();
100        self.stats.add_nb_letter(query.input_word.len());
101        self.stats.increment_nb_submitted_query();
102        self.stats.add_nb_submitted_letter(query.input_word.len());
103
104        self.current_state = "s0".to_string();
105        let mut output_letters = Vec::new();
106
107        for input_letter in query.input_word.letters() {
108            let input = input_letter.symbols();
109            let key = (self.current_state.clone(), input);
110            let (output, next_state) = self
111                .transitions
112                .get(&key)
113                .cloned()
114                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
115
116            output_letters.push(Letter::new(output));
117            self.current_state = next_state;
118        }
119
120        query.set_result(Word::from_letters(output_letters));
121        Ok(())
122    }
Source

pub fn letters(&self) -> &[Letter]

Get the letters in this word

Examples found in repository?
examples/all_eqtests_custom_kb.rs (line 217)
208    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
209        self.stats.increment_nb_query();
210        self.stats.add_nb_letter(query.input_word.len());
211        self.stats.increment_nb_submitted_query();
212        self.stats.add_nb_submitted_letter(query.input_word.len());
213
214        self.state = ATMState::Idle;
215        let mut outputs = Vec::new();
216
217        for input_letter in query.input_word.letters() {
218            let command = input_letter.symbols();
219            let (next_state, response) = self.process_input(command.as_str(), self.state);
220            self.state = next_state;
221            outputs.push(Letter::new(response));
222        }
223
224        query.set_result(Word::from_letters(outputs));
225        Ok(())
226    }
More examples
Hide additional examples
examples/vending_machine.rs (line 85)
75    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
76        self.stats.increment_nb_query();
77        self.stats.add_nb_letter(query.input_word.len());
78        self.stats.increment_nb_submitted_query();
79        self.stats.add_nb_submitted_letter(query.input_word.len());
80
81        // Reset to initial state for each query
82        self.state = VendingState::Idle;
83
84        let mut outputs = Vec::new();
85        for input_letter in query.input_word.letters() {
86            let command_string = input_letter.symbols();
87            let command = command_string.as_str();
88
89            let (next, resp) = self.process_input(command, self.state);
90            self.state = next;
91            outputs.push(Letter::new(resp));
92        }
93
94        query.set_result(Word::from_letters(outputs));
95        Ok(())
96    }
examples/custom_kb.rs (line 105)
94    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
95        self.stats.increment_nb_query();
96        self.stats.add_nb_letter(query.input_word.len());
97        self.stats.increment_nb_submitted_query();
98        self.stats.add_nb_submitted_letter(query.input_word.len());
99        // Reset to initial state for each query
100        self.state = ATMState::Idle;
101
102        // let mut state = self.state.lock().unwrap();
103        let mut outputs = Vec::new();
104
105        for input_letter in query.input_word.letters() {
106            // Extract command from letter name (format: "Letter('x')")
107            let symbol = input_letter.symbols();
108            let command = symbol.as_str();
109
110            let (next_state, response) = self.process_input(command, self.state);
111            self.state = next_state;
112            outputs.push(Letter::new(response));
113        }
114
115        query.set_result(Word::from_letters(outputs));
116        Ok(())
117    }
examples/benchmark.rs (line 98)
89    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
90        self.stats.increment_nb_query();
91        self.stats.add_nb_letter(query.input_word.len());
92        self.stats.increment_nb_submitted_query();
93        self.stats.add_nb_submitted_letter(query.input_word.len());
94
95        self.current_state = "s0".to_string();
96        let mut output_letters = Vec::new();
97
98        for input_letter in query.input_word.letters() {
99            let input = input_letter.symbols();
100            let key = (self.current_state.clone(), input);
101            let (output, next_state) = self
102                .transitions
103                .get(&key)
104                .cloned()
105                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
106
107            output_letters.push(Letter::new(output));
108            self.current_state = next_state;
109        }
110
111        query.set_result(Word::from_letters(output_letters));
112        Ok(())
113    }
examples/random_walk_eq.rs (line 107)
98    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
99        self.stats.increment_nb_query();
100        self.stats.add_nb_letter(query.input_word.len());
101        self.stats.increment_nb_submitted_query();
102        self.stats.add_nb_submitted_letter(query.input_word.len());
103
104        self.current_state = "s0".to_string();
105        let mut output_letters = Vec::new();
106
107        for input_letter in query.input_word.letters() {
108            let input = input_letter.symbols();
109            let key = (self.current_state.clone(), input);
110            let (output, next_state) = self
111                .transitions
112                .get(&key)
113                .cloned()
114                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
115
116            output_letters.push(Letter::new(output));
117            self.current_state = next_state;
118        }
119
120        query.set_result(Word::from_letters(output_letters));
121        Ok(())
122    }
Source

pub fn len(&self) -> usize

Get the length of this word

Examples found in repository?
examples/all_eqtests_custom_kb.rs (line 210)
208    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
209        self.stats.increment_nb_query();
210        self.stats.add_nb_letter(query.input_word.len());
211        self.stats.increment_nb_submitted_query();
212        self.stats.add_nb_submitted_letter(query.input_word.len());
213
214        self.state = ATMState::Idle;
215        let mut outputs = Vec::new();
216
217        for input_letter in query.input_word.letters() {
218            let command = input_letter.symbols();
219            let (next_state, response) = self.process_input(command.as_str(), self.state);
220            self.state = next_state;
221            outputs.push(Letter::new(response));
222        }
223
224        query.set_result(Word::from_letters(outputs));
225        Ok(())
226    }
More examples
Hide additional examples
examples/vending_machine.rs (line 77)
75    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
76        self.stats.increment_nb_query();
77        self.stats.add_nb_letter(query.input_word.len());
78        self.stats.increment_nb_submitted_query();
79        self.stats.add_nb_submitted_letter(query.input_word.len());
80
81        // Reset to initial state for each query
82        self.state = VendingState::Idle;
83
84        let mut outputs = Vec::new();
85        for input_letter in query.input_word.letters() {
86            let command_string = input_letter.symbols();
87            let command = command_string.as_str();
88
89            let (next, resp) = self.process_input(command, self.state);
90            self.state = next;
91            outputs.push(Letter::new(resp));
92        }
93
94        query.set_result(Word::from_letters(outputs));
95        Ok(())
96    }
examples/custom_kb.rs (line 96)
94    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
95        self.stats.increment_nb_query();
96        self.stats.add_nb_letter(query.input_word.len());
97        self.stats.increment_nb_submitted_query();
98        self.stats.add_nb_submitted_letter(query.input_word.len());
99        // Reset to initial state for each query
100        self.state = ATMState::Idle;
101
102        // let mut state = self.state.lock().unwrap();
103        let mut outputs = Vec::new();
104
105        for input_letter in query.input_word.letters() {
106            // Extract command from letter name (format: "Letter('x')")
107            let symbol = input_letter.symbols();
108            let command = symbol.as_str();
109
110            let (next_state, response) = self.process_input(command, self.state);
111            self.state = next_state;
112            outputs.push(Letter::new(response));
113        }
114
115        query.set_result(Word::from_letters(outputs));
116        Ok(())
117    }
examples/benchmark.rs (line 91)
89    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
90        self.stats.increment_nb_query();
91        self.stats.add_nb_letter(query.input_word.len());
92        self.stats.increment_nb_submitted_query();
93        self.stats.add_nb_submitted_letter(query.input_word.len());
94
95        self.current_state = "s0".to_string();
96        let mut output_letters = Vec::new();
97
98        for input_letter in query.input_word.letters() {
99            let input = input_letter.symbols();
100            let key = (self.current_state.clone(), input);
101            let (output, next_state) = self
102                .transitions
103                .get(&key)
104                .cloned()
105                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
106
107            output_letters.push(Letter::new(output));
108            self.current_state = next_state;
109        }
110
111        query.set_result(Word::from_letters(output_letters));
112        Ok(())
113    }
examples/random_walk_eq.rs (line 100)
98    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
99        self.stats.increment_nb_query();
100        self.stats.add_nb_letter(query.input_word.len());
101        self.stats.increment_nb_submitted_query();
102        self.stats.add_nb_submitted_letter(query.input_word.len());
103
104        self.current_state = "s0".to_string();
105        let mut output_letters = Vec::new();
106
107        for input_letter in query.input_word.letters() {
108            let input = input_letter.symbols();
109            let key = (self.current_state.clone(), input);
110            let (output, next_state) = self
111                .transitions
112                .get(&key)
113                .cloned()
114                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
115
116            output_letters.push(Letter::new(output));
117            self.current_state = next_state;
118        }
119
120        query.set_result(Word::from_letters(output_letters));
121        Ok(())
122    }
Source

pub fn is_empty(&self) -> bool

Check if the word is empty

Examples found in repository?
examples/memory_kb.rs (line 62)
61    fn submit_word_to_target(&mut self, word: &Word) -> Result<Word, String> {
62        if word.is_empty() {
63            return Ok(Word::new());
64        }
65
66        let initial_state = self.target.initial_state.clone();
67        let (output_word, _) = self
68            .target
69            .play_word(word, Some(&initial_state))?;
70        Ok(output_word)
71    }
Source

pub fn last_letter(&self) -> Option<&Letter>

Get the last letter

Source

pub fn append_letter(self, letter: Letter) -> Self

Append a letter to this word

Source

pub fn concatenate(&self, other: &Word) -> Word

Concatenate two words

Source

pub fn concatenate_letter(&self, letter: &Letter) -> Word

Concatenate with a single letter (optimized)

Source

pub fn prefix(&self, len: usize) -> Word

Get a prefix of the word up to (but not including) the given length

Trait Implementations§

Source§

impl Clone for Word

Source§

fn clone(&self) -> Word

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for Word

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for Word

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl Display for Word

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Hash for Word

Source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

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

Feeds a slice of this type into the given Hasher. Read more
Source§

impl PartialEq for Word

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl Eq for Word

Auto Trait Implementations§

§

impl Freeze for Word

§

impl RefUnwindSafe for Word

§

impl Send for Word

§

impl Sync for Word

§

impl Unpin for Word

§

impl UnsafeUnpin for Word

§

impl UnwindSafe for Word

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

Source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

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

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

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

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.