Struct trane::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(library_root: &Path) -> Result<Trane>

Creates a new instance of the library 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.

pub fn library_root(&self) -> String

Returns the path to the root of the course library.

pub fn mantra_count(&self) -> usize

Returns the number of mantras that have been recited by the mantra miner.

Trait Implementations

impl Blacklist for Trane

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

Adds the given unit to the blacklist.

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

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

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

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

fn all_blacklist_entries(&self) -> Result<Vec<Ustr>>

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) -> Result<Vec<Ustr>>

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

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

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

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

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

impl ExerciseScheduler for Trane

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

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<()>

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 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.

impl FilterManager for Trane

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

Gets the filter with the given ID.

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

Returns a list of filter IDs and descriptions.

impl PracticeStats for Trane

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

Retrieves the last num_scores scores of a particular exercise.

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

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<()>

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

impl ReviewList for Trane

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

Adds the given unit to the review list.

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

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

fn all_review_list_entries(&self) -> Result<Vec<Ustr>>

Returns all the entries in the review list.

impl UnitGraph for Trane

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

Adds a new course to the unit graph.

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

Adds a new lesson to the unit graph. This function is the equivalent of add_course for lessons. It also requires the ID of the course to which this lesson belongs.

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

Adds a new exercise to the unit graph. This function is the equivalent of add_course and add_lesson for exercises. It also requires the ID of the lesson to which this exercise belongs.

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

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 is not explicitly added by calling one of add_course or add_lesson.

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_course_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.

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 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_dependency_sinks(&self) -> UstrSet

Returns the dependency sinks of the graph. A dependency sink is a unit 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 check_cycles(&self) -> Result<()>

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) -> 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.