Struct Trane 

pub struct Trane { /* private fields */ }

Trane is a library for the acquisition of highly hierarchical knowledge and skills based on the principles of mastery learning and spaced repetition. Given a list of courses, its lessons and corresponding exercises, Trane presents the student with a list of exercises based on the demonstrated mastery of previous exercises. It makes sure that new material and skills are not introduced until the prerequisite material and skills have been sufficiently mastered.

Implementations

impl Trane

pub fn new_local(working_dir: &Path, library_root: &Path) -> Result<Trane>

Creates a new local instance of the Trane given the path to the root of a course library. The user data will be stored in a directory named .trane inside the library root directory. The working directory will be used to resolve relative paths.

pub fn new_local_from_serialized( library_root: &Path, serialized_library: SerializedCourseLibrary, ) -> Result<Trane>

Creates a new local instance of the Trane given the path to the root of a course library. The user data will be stored in a directory named .trane inside the library root directory. The working directory will be used to resolve relative paths.

pub fn library_root(&self) -> String

Returns the path to the root of the course library.

Trait Implementations

impl Blacklist for Trane

fn add_to_blacklist(&mut self, unit_id: Ustr) -> Result<(), BlacklistError>

Adds the given unit to the blacklist.

fn remove_from_blacklist(&mut self, unit_id: Ustr) -> Result<(), BlacklistError>

Removes the given unit from the blacklist. Do nothing if the unit is not already in the list.

fn remove_prefix_from_blacklist( &mut self, prefix: &str, ) -> Result<(), BlacklistError>

Removes all the units that match the given prefix from the blacklist.

fn blacklisted(&self, unit_id: Ustr) -> Result<bool, BlacklistError>

Returns whether the given unit is in the blacklist and should be skipped during scheduling.

fn get_blacklist_entries(&self) -> Result<Vec<Ustr>, BlacklistError>

Returns all the entries in the blacklist.

impl CourseLibrary for Trane

fn get_course_manifest(&self, course_id: Ustr) -> Option<CourseManifest>

Returns the course manifest for the given course.

fn get_lesson_manifest(&self, lesson_id: Ustr) -> Option<LessonManifest>

Returns the lesson manifest for the given lesson.

fn get_exercise_manifest(&self, exercise_id: Ustr) -> Option<ExerciseManifest>

Returns the exercise manifest for the given exercise.

fn get_course_ids(&self) -> Vec<Ustr>

Returns the IDs of all courses in the library sorted alphabetically.

fn get_lesson_ids(&self, course_id: Ustr) -> Option<Vec<Ustr>>

Returns the IDs of all lessons in the given course sorted alphabetically.

fn get_exercise_ids(&self, lesson_id: Ustr) -> Option<Vec<Ustr>>

Returns the IDs of all exercises in the given lesson sorted alphabetically.

fn get_all_exercise_ids(&self, unit_id: Option<Ustr>) -> Vec<Ustr>

Returns the IDs of all exercises in the given course sorted alphabetically.

fn get_matching_prefix( &self, prefix: &str, unit_type: Option<UnitType>, ) -> UstrSet

Returns the set of units whose ID starts with the given prefix and are of the given type. If unit_type is None, then all unit types are considered.

fn search(&self, query: &str) -> Result<Vec<Ustr>, CourseLibraryError>

Returns the IDs of all the units which match the given query.

impl ExerciseScheduler for Trane

fn get_exercise_batch( &self, filter: Option<ExerciseFilter>, ) -> Result<Vec<ExerciseManifest>, ExerciseSchedulerError>

Gets a new batch of exercises scheduled for a new trial. Contains an optimal filter to restrict the units visited during the search with the purpose of allowing students to choose which material to practice. If the filter is not provided, the scheduler will search the entire graph.

fn score_exercise( &self, exercise_id: Ustr, score: MasteryScore, timestamp: i64, ) -> Result<(), ExerciseSchedulerError>

Records the score of the given exercise’s trial. The scores are used by the scheduler to decide when to stop traversing a path and how to sort and filter all the found candidates into a final batch.

fn get_unit_score( &self, unit_id: Ustr, ) -> Result<Option<f32>, ExerciseSchedulerError>

Gets the score for the given unit. The unit can be a course, lesson, or exercise.

fn invalidate_cached_score(&self, unit_id: Ustr)

Removes any cached scores for the given unit. The score will be recomputed the next time the score is needed.

fn invalidate_cached_scores_with_prefix(&self, prefix: &str)

Removes any cached scores from units with the given prefix. The same considerations as invalidate_cached_score apply.

fn get_scheduler_options(&self) -> SchedulerOptions

Returns the options used to control the behavior of the scheduler.

fn set_scheduler_options(&mut self, options: SchedulerOptions)

Sets the options used to control the behavior of the scheduler.

fn reset_scheduler_options(&mut self)

Resets the options used to control the behavior of the scheduler to their default values.

impl FilterManager for Trane

fn get_filter(&self, id: &str) -> Option<SavedFilter>

Gets the filter with the given ID.

fn list_filters(&self) -> Vec<(String, String)>

Returns a list of filter IDs and descriptions.

impl PracticeRewards for Trane

fn get_rewards( &self, unit_id: Ustr, num_rewards: usize, ) -> Result<Vec<UnitReward>, PracticeRewardsError>

Retrieves the last given number of rewards of a particular lesson or course. The rewards are in descending order according to the timestamp.

fn record_unit_reward( &mut self, unit_id: Ustr, reward: &UnitReward, ) -> Result<bool, PracticeRewardsError>

Records the reward assigned to the unit. Only lessons and courses should have rewards. However, the caller must enforce this requirement. Because similar exercises can write similar rewards in quick succession, the implementation can choose to skip the reward if it is deemed too similar to another recent one. If that’s the case, the function returns false.

fn trim_rewards( &mut self, num_rewards: usize, ) -> Result<(), PracticeRewardsError>

Deletes all rewards of the given unit except for the last given number with the aim of keeping the storage size under check.

fn remove_rewards_with_prefix( &mut self, prefix: &str, ) -> Result<(), PracticeRewardsError>

Removes all the rewards from the units that match the given prefix.

impl PracticeStats for Trane

fn get_scores( &self, exercise_id: Ustr, num_scores: usize, ) -> Result<Vec<ExerciseTrial>, PracticeStatsError>

Retrieves the last num_scores scores of a particular exercise. The scores are returned in descending order according to the timestamp.

fn record_exercise_score( &mut self, exercise_id: Ustr, score: MasteryScore, timestamp: i64, ) -> Result<(), PracticeStatsError>

Records the score assigned to the exercise in a particular trial. Therefore, the score is a value of the MasteryScore enum instead of a float. Only units of type UnitType::Exercise should have scores recorded. However, the enforcement of this requirement is left to the caller.

fn trim_scores(&mut self, num_scores: usize) -> Result<(), PracticeStatsError>

Deletes all the exercise trials except for the last num_scores with the aim of keeping the storage size under check.

fn remove_scores_with_prefix( &mut self, prefix: &str, ) -> Result<(), PracticeStatsError>

Removes all the scores from the units that match the given prefix.

impl PreferencesManager for Trane

fn get_user_preferences( &self, ) -> Result<UserPreferences, PreferencesManagerError>

Gets the current user preferences.

fn set_user_preferences( &mut self, preferences: UserPreferences, ) -> Result<(), PreferencesManagerError>

Sets the user preferences to the given value.

impl ReviewList for Trane

fn add_to_review_list(&mut self, unit_id: Ustr) -> Result<(), ReviewListError>

Adds the given unit to the review list.

fn remove_from_review_list( &mut self, unit_id: Ustr, ) -> Result<(), ReviewListError>

Removes the given unit from the review list. Do nothing if the unit is not already in the list.

fn get_review_list_entries(&self) -> Result<Vec<Ustr>, ReviewListError>

Returns all the entries in the review list.

impl StudySessionManager for Trane

fn get_study_session(&self, id: &str) -> Option<StudySession>

Gets the study session with the given ID.

fn list_study_sessions(&self) -> Vec<(String, String)>

Returns a list of study session IDs and descriptions.

impl UnitGraph for Trane

fn add_course(&mut self, course_id: Ustr) -> Result<(), UnitGraphError>

Adds a new course to the unit graph.

fn add_lesson( &mut self, lesson_id: Ustr, course_id: Ustr, ) -> Result<(), UnitGraphError>

Adds a new lesson to the unit graph. It also takes the ID of the course to which this lesson belongs.

fn add_exercise( &mut self, exercise_id: Ustr, lesson_id: Ustr, ) -> Result<(), UnitGraphError>

Adds a new exercise to the unit graph. It also takes the ID of the lesson to which this exercise belongs.

fn add_dependencies( &mut self, unit_id: Ustr, unit_type: UnitType, dependencies: &[Ustr], ) -> Result<(), UnitGraphError>

Takes a unit and its dependencies and updates the graph accordingly. Returns an error if unit_type is UnitType::Exercise as only courses and lessons are allowed to have dependencies. An error is also returned if the unit was not previously added by calling one of add_course or add_lesson.

fn add_encompassed( &mut self, unit_id: Ustr, dependencies: &[Ustr], encompassed: &[(Ustr, f32)], ) -> Result<(), UnitGraphError>

Adds the list of encompassed units for the given unit to the graph. Dependencies not in the list of encompassed units are added with a default weight of 1.0. Returns an error if any of the weights are not within the range [0.0, 1.0].

fn set_encompasing_equals_dependency(&mut self)

Tells UnitGraph that the encompassing and dependency graphs are the same. That is, no manifest explicitly declared encompassed units. In this case, the encompassing graph is identical to the dependency graph with all weights set to 1.0. The caller should use this function after building the full graph to avoid the overhead of storing two identical graphs.

fn encompasing_equals_dependency(&self) -> bool

Whether the encompassing and dependency graphs are effectively the same.

fn add_superseded(&mut self, unit_id: Ustr, superseded: &[Ustr])

Adds the list of superseded units for the given unit to the graph.

fn get_unit_type(&self, unit_id: Ustr) -> Option<UnitType>

Returns the type of the given unit.

fn get_course_lessons(&self, course_id: Ustr) -> Option<UstrSet>

Returns the lessons belonging to the given course.

fn get_starting_lessons(&self, course_id: Ustr) -> Option<UstrSet>

Returns the starting lessons for the given course.

fn update_starting_lessons(&mut self)

Updates the starting lessons for all courses. The starting lessons of the course are those of its lessons that should be practiced first when the course is introduced to the student. The scheduler uses them to traverse through the other lessons in the course in the correct order. This function should be called once after all the courses and lessons have been added to the graph.

fn get_lesson_course(&self, lesson_id: Ustr) -> Option<Ustr>

Returns the course to which the given lesson belongs.

fn get_lesson_exercises(&self, lesson_id: Ustr) -> Option<UstrSet>

Returns the exercises belonging to the given lesson.

fn get_exercise_lesson(&self, exercise_id: Ustr) -> Option<Ustr>

Returns the lesson to which the given exercise belongs.

fn get_dependencies(&self, unit_id: Ustr) -> Option<UstrSet>

Returns the weights of the dependencies of the given unit.

fn get_dependents(&self, unit_id: Ustr) -> Option<UstrSet>

Returns all the units which depend on the given unit.

fn get_encompasses(&self, unit_id: Ustr) -> Option<Vec<(Ustr, f32)>>

Returns the units that this unit encompasses.

fn get_encompassed_by(&self, unit_id: Ustr) -> Option<Vec<(Ustr, f32)>>

Returns the units that the given unit is encompassed by.

fn get_dependency_sinks(&self) -> UstrSet

Returns the dependency sinks of the graph. A dependency sink is a unit with no dependencies from which a walk of the entire unit graph needs to start. Because the lessons in a course implicitly depend on their course, properly initialized lessons do not belong to this set.

fn get_supersedes(&self, unit_id: Ustr) -> Option<UstrSet>

Returns the units that this unit supersedes.

fn get_superseded_by(&self, unit_id: Ustr) -> Option<UstrSet>

Returns the units that the given unit is superseded by.

fn check_cycles(&self) -> Result<(), UnitGraphError>

Performs a cycle check on the graph, done currently when opening the Trane library to prevent any infinite traversal of the graph and immediately inform the user of the issue.

fn generate_dot_graph(&self, courses_only: bool) -> String

Generates a DOT graph of the dependent graph. DOT files are used by Graphviz to visualize a graph, in this case the dependent graph. This operation was suggested in issue #13 in the trane-cli repo.

impl Send for Trane

impl Sync for Trane