🥮 mooncakes.io

neighbor_rota

Explainable community care and volunteer scheduling engine

scheduling
rostering
community-care
constraint-solving
explainable
moon add zjk9993/neighbor_rota@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
4 days ago
Downloads
2
README

#NeighborRota

NeighborRota is an explainable community-care and volunteer scheduling engine implemented in MoonBit. It validates CSV or MoonBit-native inputs, evaluates skills, time windows, workloads, breaks and travel, constructs a deterministic schedule, explains infeasible visits and reschedules after operational events.

let request = @neighbor_rota.demo_request(@neighbor_rota.CommunityCare)
let schedule = @neighbor_rota.solve(request)
println(@neighbor_rota.schedule_summary(schedule))

The package includes a reusable API, native CLI, Wasm-GC build, 109 automated tests and three fictional demonstration scenarios. It is planning software only; it does not provide medical advice, employee monitoring, real-time tracking or automated operational control.

Repository: https://github.com/zjk9993/zjk9993

License: Apache-2.0.

#
Assignment

source
pub(all) struct Assignment {
  visit_id : String
  worker_id : String
  start_minute : Int
  end_minute : Int
  travel_before_minutes : Int
  score : Int
  reasons : Array[String]
} derive(Eq, 
Debug)

One fixed assignment in a schedule.

#
AssignmentChange

source
pub(all) enum AssignmentChange {
  Added(assignment~ : Assignment)
  Removed(assignment~ : Assignment)
  Reassigned(before~ : Assignment, after~ : Assignment)
  Retimed(before~ : Assignment, after~ : Assignment)
  ReassignedAndRetimed(before~ : Assignment, after~ : Assignment)
  Unchanged(assignment~ : Assignment)
} derive(Eq, 
Debug)

One assignment-level difference between two schedules.

#
Candidate

source
pub(all) struct Candidate {
  worker_id : String
  visit_id : String
  start_minute : Int
  end_minute : Int
  travel_before_minutes : Int
  raw_score : Int
  reasons : Array[String]
} derive(Eq, 
Debug)

One feasible placement before it becomes an assignment.

#
Candidate::to_assignment

source
fn Candidate::to_assignment(self : Candidate) -> Assignment

Convert one candidate to the public assignment representation.

#
CandidateSearch

source
pub(all) struct CandidateSearch {
  candidates : Array[Candidate]
  rejected : Array[FeasibilityResult]
} derive(Eq, 
Debug)

Candidate search result retains rejected evaluations for diagnostics.

#
ConstraintCode

source
pub(all) enum ConstraintCode {
  WorkerUnavailable
  WorkerForbidden
  MissingSkill
  OutsideAvailability
  TimeConflict
  InsufficientTravelBefore
  InsufficientTravelAfter
  BreakViolation
  MaxMinutesExceeded
  MaxVisitsExceeded
  VisitWindowViolation
} derive(Eq, 
Debug)

Stable codes emitted when a worker cannot take one candidate visit.

#
ConstraintFailure

source
pub(all) struct ConstraintFailure {
  code : ConstraintCode
  message : String
  worker_id : String
  visit_id : String
} derive(Eq, 
Debug)

One failed hard constraint with a human explanation.

#
CsvDocument

source
pub(all) struct CsvDocument {
  rows : Array[CsvRow]
  diagnostics : Array[Diagnostic]
} derive(Eq, 
Debug)

Parsed CSV document with non-fatal syntax diagnostics.

#
CsvRow

source
pub(all) struct CsvRow {
  line : Int
  fields : Array[String]
} derive(Eq, 
Debug)

One lexical CSV row before domain conversion.

#
DemoScenario

source
pub(all) enum DemoScenario {
  CommunityCare
  CampusVolunteers
  SuddenAbsence
} derive(Eq, 
Debug)

Named demonstration scenarios distributed with the package.

#
Diagnostic

source
pub(all) struct Diagnostic {
  level : DiagnosticLevel
  code : String
  message : String
  entity_id : String?
  field : String?
} derive(Eq, 
Debug)

A validation or solver diagnostic suitable for machine processing.

#
Diagnostic::at_field

source
fn Diagnostic::at_field(self : Diagnostic, field : String) -> Diagnostic

Attach an input field name to a diagnostic.

#
Diagnostic::for_entity

source
fn Diagnostic::for_entity(self : Diagnostic, id : String) -> Diagnostic

Attach a domain entity identifier to a diagnostic.

#
DiagnosticLevel

source
pub(all) enum DiagnosticLevel {
  Info
  Warning
  Error
} derive(Eq, 
Debug)

Severity attached to a stable diagnostic code.

#
FeasibilityResult

source
pub(all) struct FeasibilityResult {
  feasible : Bool
  failures : Array[ConstraintFailure]
  travel_before_minutes : Int
  travel_after_minutes : Int
} derive(Eq, 
Debug)

Complete feasibility result for one candidate placement.

#
Location

source
pub(all) struct Location {
  id : String
  x : Int
  y : Int
  zone : String
} derive(Eq, 
Debug)

Integer coordinates used for deterministic travel estimates.

#
Priority

source
pub(all) enum Priority {
  Low
  Normal
  High
  Critical
} derive(Eq, 
Debug)

Service urgency. Higher values receive stronger scheduling preference.

#
ReasonCount

source
pub(all) struct ReasonCount {
  code : String
  count : Int
} derive(Eq, 
Debug)

Frequency of one stable unassigned reason code.

#
RescheduleReport

source
pub(all) struct RescheduleReport {
  baseline : Schedule
  updated : Schedule
  events : Array[ScheduleEvent]
  changes : Array[AssignmentChange]
  diagnostics : Array[Diagnostic]
  changed_assignments : Int
  preserved_assignments : Int
  newly_unassigned : Int
  score_change : Int
} derive(Eq, 
Debug)

Complete impact summary for an event-driven reschedule.

#
RotaEngine

source
pub(all) struct RotaEngine {
  version : String
} derive(Eq, 
Debug)

Public stateless scheduling engine.

#
RotaEngine::solve

source
fn RotaEngine::solve(self : RotaEngine, request : ScheduleRequest) -> Schedule

Solve through the engine-style API used in the project application.

#
Schedule

source
pub(all) struct Schedule {
  schema : String
  assignments : Array[Assignment]
  unassigned : Array[UnassignedVisit]
  diagnostics : Array[Diagnostic]
  score : ScheduleScore
  feasible : Bool
} derive(Eq, 
Debug)

Complete auditable scheduling result.

#
ScheduleAnalytics

source
pub(all) struct ScheduleAnalytics {
  total_visits : Int
  required_visits : Int
  assigned_visits : Int
  assigned_required_visits : Int
  optional_unassigned : Int
  required_unassigned : Int
  coverage_percent : Int
  required_coverage_percent : Int
  total_service_minutes : Int
  total_travel_minutes : Int
  travel_share_percent : Int
  average_worker_utilization_percent : Int
  busiest_worker_id : String?
  busiest_worker_minutes : Int
  zones_served : Array[String]
  reason_counts : Array[ReasonCount]
} derive(Eq, 
Debug)

Aggregate acceptance metrics for one schedule and request.

#
ScheduleEvent

source
pub(all) enum ScheduleEvent {
  WorkerAbsent(worker_id~ : String, from_minute~ : Int, to_minute~ : Int)
  VisitCancelled(visit_id~ : String)
  VisitDelayed(visit_id~ : String, delay_minutes~ : Int)
  EmergencyVisit(visit~ : Visit)
  WorkerCapacityChanged(worker_id~ : String, max_minutes~ : Int, max_visits~ : Int)
} derive(Eq, 
Debug)

Operational event applied after a baseline schedule has been published.

#
SchedulePolicy

source
pub(all) struct SchedulePolicy {
  travel_minutes_per_unit : Int
  cross_zone_penalty_minutes : Int
  priority_weight : Int
  preference_weight : Int
  continuity_weight : Int
  travel_weight : Int
  fairness_weight : Int
  disruption_weight : Int
  allow_optional_unassigned : Bool
  local_search_rounds : Int
} derive(Eq, 
Debug)

Policy weights and operational limits.

#
ScheduleRequest

source
pub(all) struct ScheduleRequest {
  workers : Array[Worker]
  visits : Array[Visit]
  policy : SchedulePolicy
  baseline : Schedule?
} derive(Eq, 
Debug)

All inputs required for a deterministic scheduling run.

#
ScheduleScore

source
pub(all) struct ScheduleScore {
  total : Int
  assigned_priority : Int
  travel_penalty : Int
  fairness_penalty : Int
  continuity_bonus : Int
  preference_bonus : Int
  disruption_penalty : Int
} derive(Eq, 
Debug)

Aggregate dimensions used to compare schedules.

#
Skill

source
pub(all) struct Skill {
  name : String
  level : Int
} derive(Eq, 
Debug)

A capability that may be required by a service visit.

#
TimeWindow

source
pub(all) struct TimeWindow {
  start_minute : Int
  end_minute : Int
} derive(Eq, 
Debug)

A half-open minute range [start, end) within one planning horizon.

#
TimeWindow::contains

source
fn TimeWindow::contains(self : TimeWindow, other : TimeWindow) -> Bool

Whether this window fully contains another window.

#
TimeWindow::duration

source
fn TimeWindow::duration(self : TimeWindow) -> Int

Duration of the window in minutes. Invalid windows report zero here.

#
TimeWindow::latest_start

source
fn TimeWindow::latest_start(self : TimeWindow, duration : Int) -> Int

Clamp a requested start so a service duration remains inside the window.

#
TimeWindow::overlaps

source
fn TimeWindow::overlaps(self : TimeWindow, other : TimeWindow) -> Bool

Whether two half-open windows overlap.

#
TravelLeg

source
pub(all) struct TravelLeg {
  worker_id : String
  from_location_id : String
  to_location_id : String
  depart_minute : Int
  arrive_minute : Int
  travel_minutes : Int
  cross_zone : Bool
} derive(Eq, 
Debug)

Travel leg retained for route explanations and reports.

#
UnassignedVisit

source
pub(all) struct UnassignedVisit {
  visit_id : String
  reason_codes : Array[String]
  details : Array[String]
} derive(Eq, 
Debug)

A visit that could not be placed, with stable reason codes.

#
Visit

source
pub(all) struct Visit {
  id : String
  recipient_id : String
  title : String
  location : Location
  window : TimeWindow
  duration_minutes : Int
  required_skills : Array[Skill]
  priority : Priority
  preferred_worker_ids : Array[String]
  forbidden_worker_ids : Array[String]
  continuity_group : String?
  required : Bool
} derive(Eq, 
Debug)

A visit requested by a community service recipient.

#
Visit::forbids

source
fn Visit::forbids(self : Visit, worker_id : String) -> Bool

Whether a worker identifier is explicitly forbidden for this visit.

#
Visit::prefers

source
fn Visit::prefers(self : Visit, worker_id : String) -> Bool

Whether a worker identifier is explicitly preferred for this visit.

#
VisitBatch

source
pub(all) struct VisitBatch {
  visits : Array[Visit]
  diagnostics : Array[Diagnostic]
} derive(Eq, 
Debug)

Visit import result. Valid rows remain available when other rows fail.

#
Worker

source
pub(all) struct Worker {
  id : String
  display_name : String
  kind : WorkerKind
  skills : Array[Skill]
  availability : Array[TimeWindow]
  home : Location
  max_minutes : Int
  max_visits : Int
  min_break_minutes : Int
  preferred_zones : Array[String]
  unavailable : Bool
} derive(Eq, 
Debug)

A person who may be assigned one or more visits.

#
Worker::has_skill

source
fn Worker::has_skill(self : Worker, required : Skill) -> Bool

Whether the worker has a required skill at the requested level.

#
Worker::is_available

source
fn Worker::is_available(self : Worker, interval : TimeWindow) -> Bool

Whether the worker is available for an entire interval.

#
Worker::skill_level

source
fn Worker::skill_level(self : Worker, name : String) -> Int

Return the worker's level for a named skill, or zero when absent.

#
WorkerBatch

source
pub(all) struct WorkerBatch {
  workers : Array[Worker]
  diagnostics : Array[Diagnostic]
} derive(Eq, 
Debug)

Worker import result. Valid rows remain available when other rows fail.

#
WorkerKind

source
pub(all) enum WorkerKind {
  Volunteer
  CareWorker
  Coordinator
} derive(Eq, 
Debug)

Worker classifications are useful for reporting and policy decisions.

#
WorkerLoad

source
pub(all) struct WorkerLoad {
  worker_id : String
  visit_count : Int
  service_minutes : Int
  travel_minutes : Int
  utilization_percent : Int
} derive(Eq, 
Debug)

Per-worker load retained for fairness reports.

#
SCHEMA_VERSION

source
let SCHEMA_VERSION : String

Semantic version of the public scheduling model.

#
abs_int

source
fn abs_int(value : Int) -> Int

Integer absolute value without relying on target-specific helpers.

#
all_worker_loads

source
fn all_worker_loads(workers : Array[Worker], assignments : Array[Assignment]) -> Array[WorkerLoad]

Compute loads for all workers in input order.

#
analytics_summary

source
fn analytics_summary(value : ScheduleAnalytics) -> String

Human-readable analytics for acceptance reports.

#
analyze_schedule

source
fn analyze_schedule(schedule : Schedule, request : ScheduleRequest) -> ScheduleAnalytics

Compute transparent acceptance metrics from a schedule.

#
apply_event

source
fn apply_event(request : ScheduleRequest, event : ScheduleEvent) -> ScheduleRequest

Apply one validated event to a request without mutating the caller.

#
apply_events

source
fn apply_events(request : ScheduleRequest, events : Array[ScheduleEvent]) -> (ScheduleRequest, Array[Diagnostic])

Apply events sequentially after validating them against evolving state.

#
assigned_minutes

source
fn assigned_minutes(assignments : Array[Assignment], worker_id : String) -> Int

Total assigned service time for a worker.

#
assigned_priority_units

source
fn assigned_priority_units(assignments : Array[Assignment], visits : Array[Visit]) -> Int

Weighted assigned priority across the schedule.

#
assigned_zones

source
fn assigned_zones(assignments : Array[Assignment], visits : Array[Visit]) -> Array[String]

List service zones represented by assigned visits.

#
assignment_before

source
fn assignment_before(left : Assignment, right : Assignment) -> Bool

Stable assignment comparison for serialized schedules.

#
assignment_change_name

source
fn assignment_change_name(change : AssignmentChange) -> String

Stable name for assignment change categories.

#
assignment_change_visit_id

source
fn assignment_change_visit_id(change : AssignmentChange) -> String

Visit id affected by one change.

#
assignment_location

source
fn assignment_location(assignment : Assignment, visits : Array[Visit]) -> Location?

Resolve the visit location for an assignment.

#
assignment_to_json

source
fn assignment_to_json(value : Assignment) -> String

Render one assignment as a stable JSON object.

#
assignments_for_worker

source
fn assignments_for_worker(assignments : Array[Assignment], worker_id : String) -> Array[Assignment]

Select all assignments belonging to a worker.

#
assignments_to_csv

source
fn assignments_to_csv(values : Array[Assignment]) -> String

Serialize assignment rows for spreadsheet analysis.

#
audit_schedule

source
fn audit_schedule(schedule : Schedule, request : ScheduleRequest) -> Array[Diagnostic]

Verify every assignment independently from the solver implementation.

#
average_utilization

source
fn average_utilization(loads : Array[WorkerLoad]) -> Int

Average worker utilization from existing normalized loads.

#
busiest_worker

source
fn busiest_worker(loads : Array[WorkerLoad]) -> (String?, Int)

Determine the busiest worker by service minutes with stable id tie-break.

#
candidate_reasons

source
fn candidate_reasons(worker : Worker, visit : Visit, feasibility : FeasibilityResult) -> Array[String]

Explanations attached to one accepted candidate.

#
candidate_score

source
fn candidate_score(worker : Worker, visit : Visit, start_minute : Int, feasibility : FeasibilityResult, assignments : Array[Assignment], policy : SchedulePolicy) -> Int

Soft score for one feasible candidate.

#
candidate_start_minutes

source
fn candidate_start_minutes(visit : Visit, step_minutes? : Int) -> Array[Int]

Generate deterministic candidate start points for a visit.

#
clamp_int

source
fn clamp_int(value : Int, lower : Int, upper : Int) -> Int

Clamp an integer to an inclusive range.

#
constraint_code_name

source
fn constraint_code_name(code : ConstraintCode) -> String

Stable machine name for constraint codes.

#
constraint_details

source
fn constraint_details(results : Array[FeasibilityResult]) -> Array[String]

Collect failure descriptions while preserving evaluation order.

#
continuity_units

source
fn continuity_units(assignments : Array[Assignment], visits : Array[Visit], workers : Array[Worker]) -> Int

Reward additional visits in a group assigned to the same worker.

#
copy_array

source
fn[T] copy_array(values : Array[T]) -> Array[T]

Copy an array while preserving order.

#
count_assigned_required

source
fn count_assigned_required(assignments : Array[Assignment], visits : Array[Visit]) -> Int

Count assigned visits that are required.

#
count_diagnostics

source
fn count_diagnostics(diagnostics : Array[Diagnostic], level : DiagnosticLevel) -> Int

Count diagnostics at one severity.

#
count_required_visits

source
fn count_required_visits(visits : Array[Visit]) -> Int

Count required visits in a request.

#
count_string

source
fn count_string(values : Array[String], target : String) -> Int

Count exact string matches.

#
count_unassigned_reasons

source
fn count_unassigned_reasons(unassigned : Array[UnassignedVisit]) -> Array[ReasonCount]

Aggregate unassigned reason codes into stable sorted counters.

#
default_policy

source
fn default_policy() -> SchedulePolicy

Balanced policy for the built-in demonstrations.

#
demo_request

source
fn demo_request(scenario : DemoScenario) -> ScheduleRequest

Build a complete request for a named scenario.

#
demo_scenario_name

source
fn demo_scenario_name(value : DemoScenario) -> String

Stable name for a demonstration scenario.

#
describe_assignment_change

source
fn describe_assignment_change(change : AssignmentChange) -> String

Concise human explanation of one schedule change.

#
describe_travel

source
fn describe_travel(from : Location, to : Location, policy : SchedulePolicy) -> String

Route description suitable for CLI and Markdown output.

#
diagnostic_level_name

source
fn diagnostic_level_name(level : DiagnosticLevel) -> String

Stable human-readable name for diagnostic levels.

#
diagnostics_have_errors

source
fn diagnostics_have_errors(diagnostics : Array[Diagnostic]) -> Bool

True when any diagnostic blocks scheduling.

#
diff_schedules

source
fn diff_schedules(baseline : Schedule, updated : Schedule) -> Array[AssignmentChange]

Compute assignment changes in stable visit-id order.

#
disruption_units

source
fn disruption_units(assignments : Array[Assignment], baseline : Schedule?) -> Int

Count assignments changed relative to an optional baseline schedule.

#
earliest_containing_start

source
fn earliest_containing_start(worker : Worker, interval : TimeWindow) -> Int?

Earliest start of an availability window that contains an interval.

#
error_diagnostic

source
fn error_diagnostic(code : String, message : String) -> Diagnostic

Build an error diagnostic.

#
evaluate_feasibility

source
fn evaluate_feasibility(worker : Worker, visit : Visit, start_minute : Int, assignments : Array[Assignment], visits : Array[Visit], policy : SchedulePolicy) -> FeasibilityResult

Evaluate a candidate against all hard constraints.

#
event_kind

source
fn event_kind(event : ScheduleEvent) -> String

Stable event kind used by logs and JSON reports.

#
fairness_deviation

source
fn fairness_deviation(loads : Array[WorkerLoad]) -> Int

Sum absolute deviations from the average assigned service time.

#
find_assignment

source
fn find_assignment(assignments : Array[Assignment], visit_id : String) -> Assignment?

Find an assignment for a visit.

#
find_visit

source
fn find_visit(visits : Array[Visit], id : String) -> Visit?

Find a visit by identifier.

#
find_worker

source
fn find_worker(workers : Array[Worker], id : String) -> Worker?

Find a worker by identifier.

#
improve_schedule

source
fn improve_schedule(schedule : Schedule, request : ScheduleRequest) -> Schedule

Improve a constructive schedule without sacrificing determinism.

#
info_diagnostic

source
fn info_diagnostic(code : String, message : String) -> Diagnostic

Build an informational diagnostic.

#
interval_conflicts

source
fn interval_conflicts(assignments : Array[Assignment], worker_id : String, interval : TimeWindow) -> Bool

Whether an interval overlaps any existing worker assignment.

#
location

source
fn location(id : String, x : Int, y : Int, zone : String) -> Location

Create a location in a named service zone.

#
location_distance

source
fn location_distance(left : Location, right : Location) -> Int

Manhattan distance is deterministic, integer-only and easy to audit.

#
max_int

source
fn max_int(left : Int, right : Int) -> Int

Return the larger integer.

#
min_int

source
fn min_int(left : Int, right : Int) -> Int

Return the smaller integer.

#
missing_skills

source
fn missing_skills(worker : Worker, visit : Visit) -> Array[Skill]

Check every required skill and retain all missing requirements.

#
new_rota_engine

source
fn new_rota_engine() -> RotaEngine

Construct the stable NeighborRota scheduling engine.

#
next_assignment

source
fn next_assignment(assignments : Array[Assignment], worker_id : String, end_minute : Int) -> Assignment?

Find the assignment immediately after a proposed end.

#
parse_availability

source
fn parse_availability(input : String, entity_id : String) -> (Array[TimeWindow], Array[Diagnostic])

Parse start-end|start-end availability declarations.

#
parse_csv_bool

source
fn parse_csv_bool(input : String) -> Bool?

Parse common CSV boolean spellings.

#
parse_csv_document

source
fn parse_csv_document(input : String) -> CsvDocument

Parse commas, quoted cells, doubled quotes and LF/CRLF line endings.

#
parse_csv_int

source
fn parse_csv_int(input : String) -> Int?

Parse a base-10 integer without accepting decimal or exponent notation.

#
parse_demo_scenario

source
fn parse_demo_scenario(name : String) -> DemoScenario?

Parse a scenario name accepted by the CLI.

#
parse_pipe_list

source
fn parse_pipe_list(input : String) -> Array[String]

Split a pipe-delimited list, trimming and discarding empty items.

#
parse_skills

source
fn parse_skills(input : String, entity_id : String) -> (Array[Skill], Array[Diagnostic])

Parse name:level|name:level skill declarations.

#
parse_visits_csv

source
fn parse_visits_csv(input : String) -> VisitBatch

Parse the documented visit CSV format.

#
parse_workers_csv

source
fn parse_workers_csv(input : String) -> WorkerBatch

Parse the documented worker CSV format.

#
preference_units

source
fn preference_units(assignments : Array[Assignment], visits : Array[Visit]) -> Int

Count assignments that satisfy explicit worker preferences.

#
previous_assignment

source
fn previous_assignment(assignments : Array[Assignment], worker_id : String, start_minute : Int) -> Assignment?

Find the assignment immediately before a proposed start.

#
previous_location

source
fn previous_location(worker : Worker, assignments : Array[Assignment], visits : Array[Visit], start_minute : Int) -> Location

Location occupied immediately before a proposed visit.

#
priority_name

source
fn priority_name(priority : Priority) -> String

Stable human-readable name for priority values.

#
priority_value

source
fn priority_value(priority : Priority) -> Int

Numeric priority used by deterministic ordering and scoring.

#
push_unique_string

source
fn push_unique_string(values : Array[String], value : String) -> Unit

Insert a string only when it is not already present.

#
replace_assignment

source
fn replace_assignment(assignments : Array[Assignment], replacement : Assignment) -> Array[Assignment]

Replace one assignment by visit id while preserving all others.

#
request_from_csv

source
fn request_from_csv(workers_csv : String, visits_csv : String) -> (ScheduleRequest, Array[Diagnostic])

Parse both input documents and construct a validated request.

#
reschedule

source
fn reschedule(baseline : Schedule, request : ScheduleRequest, events : Array[ScheduleEvent]) -> RescheduleReport

Re-solve after operational events while penalizing unnecessary changes.

#
reschedule_summary

source
fn reschedule_summary(report : RescheduleReport) -> String

Deterministic summary for logs and the CLI.

#
reschedule_to_markdown

source
fn reschedule_to_markdown(value : RescheduleReport) -> String

Markdown impact report for an event-driven update.

#
run_absence_demo

source
fn run_absence_demo() -> RescheduleReport

Run the absence demonstration and return its impact report.

#
run_demo

source
fn run_demo(scenario : DemoScenario) -> Schedule

Solve one built-in demonstration.

#
schedule_request

source
fn schedule_request(workers : Array[Worker], visits : Array[Visit]) -> ScheduleRequest

Create a request without a previous schedule.

#
schedule_summary

source
fn schedule_summary(value : Schedule) -> String

Compact terminal summary.

#
schedule_to_json

source
fn schedule_to_json(value : Schedule) -> String

Serialize a schedule for API consumers and reproducibility tests.

#
schedule_to_markdown

source
fn schedule_to_markdown(value : Schedule) -> String

Human-oriented Markdown report.

#
score_schedule

source
fn score_schedule(assignments : Array[Assignment], workers : Array[Worker], visits : Array[Visit], policy : SchedulePolicy, baseline : Schedule?) -> ScheduleScore

Build a transparent multi-dimensional schedule score.

#
score_summary

source
fn score_summary(value : ScheduleScore) -> String

Short deterministic score summary.

#
search_candidates

source
fn search_candidates(visit : Visit, workers : Array[Worker], assignments : Array[Assignment], visits : Array[Visit], policy : SchedulePolicy) -> CandidateSearch

Search every worker and start point for one visit.

#
skill

source
fn skill(name : String, level : Int) -> Skill

Create a named skill with a positive proficiency level.

#
solve

source
fn solve(request : ScheduleRequest) -> Schedule

Main scheduling function: validate, construct and locally improve.

#
solve_constructive

source
fn solve_constructive(request : ScheduleRequest) -> Schedule

Build a deterministic schedule with urgency-first constructive search.

#
sort_assignments_by_time

source
fn sort_assignments_by_time(values : Array[Assignment]) -> Array[Assignment]

Sort a worker's assignments by start minute and then visit id.

#
sort_candidates

source
fn sort_candidates(values : Array[Candidate]) -> Array[Candidate]

Sort by descending score with stable worker, start and visit tie breakers.

#
sort_schedule_assignments

source
fn sort_schedule_assignments(values : Array[Assignment]) -> Array[Assignment]

Sort schedule assignments for reproducible output.

#
sort_strings

source
fn sort_strings(values : Array[String]) -> Array[String]

Sort strings lexicographically without mutating the caller's array.

#
sort_visits_for_scheduling

source
fn sort_visits_for_scheduling(values : Array[Visit]) -> Array[Visit]

Stable urgency ordering used by the constructive solver.

#
string_array_contains

source
fn string_array_contains(values : Array[String], target : String) -> Bool

Whether a string occurs in an array.

#
subtract_window

source
fn subtract_window(available : TimeWindow, absent : TimeWindow) -> Array[TimeWindow]

Subtract an absence window from one availability window.

#
time_window

source
fn time_window(start_minute : Int, end_minute : Int) -> TimeWindow

Construct a time window without silently normalizing invalid values.

#
total_schedule_travel

source
fn total_schedule_travel(assignments : Array[Assignment]) -> Int

Total travel minutes represented by a schedule.

#
travel_before_candidate

source
fn travel_before_candidate(worker : Worker, visit : Visit, assignments : Array[Assignment], visits : Array[Visit], policy : SchedulePolicy, start_minute : Int) -> Int

Estimated travel before a proposed assignment.

#
travel_leg

source
fn travel_leg(worker_id : String, from : Location, to : Location, depart_minute : Int, policy : SchedulePolicy) -> TravelLeg

Construct a travel leg from a departure time.

#
travel_minutes

source
fn travel_minutes(left : Location, right : Location, policy : SchedulePolicy) -> Int

Estimated travel minutes between two locations under one policy.

#
unassigned_breakdown

source
fn unassigned_breakdown(unassigned : Array[UnassignedVisit], visits : Array[Visit]) -> (Int, Int)

Count required and optional unassigned visits separately.

#
unique_constraint_codes

source
fn unique_constraint_codes(results : Array[FeasibilityResult]) -> Array[String]

Collect unique failure codes from several rejected candidates.

#
validate_event

source
fn validate_event(event : ScheduleEvent, request : ScheduleRequest) -> Array[Diagnostic]

Validate one operational event against the current request.

#
validate_location

source
fn validate_location(value : Location) -> Array[Diagnostic]

Validate location identity and coordinate bounds.

#
validate_policy

source
fn validate_policy(value : SchedulePolicy) -> Array[Diagnostic]

Validate policy weights and search limits.

#
validate_request

source
fn validate_request(request : ScheduleRequest) -> Array[Diagnostic]

Validate a complete scheduling request before solving.

#
validate_skill

source
fn validate_skill(value : Skill, entity_id : String) -> Array[Diagnostic]

Validate skill name and level.

#
validate_time_window

source
fn validate_time_window(window : TimeWindow, entity_id : String, field : String) -> Array[Diagnostic]

Validate one time window and retain an entity context.

#
validate_visit

source
fn validate_visit(value : Visit) -> Array[Diagnostic]

Validate one requested visit independently.

#
validate_worker

source
fn validate_worker(value : Worker) -> Array[Diagnostic]

Validate one worker independently from other request entities.

#
visit

source
fn visit(id : String, recipient_id : String, title : String, location : Location, window : TimeWindow, duration_minutes : Int) -> Visit

Construct a visit with no skill or continuity requirements.

#
visit_before

source
fn visit_before(left : Visit, right : Visit) -> Bool

Compare visits by required status, priority, flexibility, duration and id.

#
warning_diagnostic

source
fn warning_diagnostic(code : String, message : String) -> Diagnostic

Build a warning diagnostic.

#
without_assignment

source
fn without_assignment(assignments : Array[Assignment], visit_id : String) -> Array[Assignment]

Remove one assignment by visit id.

#
worker

source
fn worker(id : String, display_name : String, kind : WorkerKind, home : Location) -> Worker

Construct a worker with conservative defaults.

#
worker_kind_name

source
fn worker_kind_name(kind : WorkerKind) -> String

Stable human-readable name for worker kinds.

#
worker_load

source
fn worker_load(worker : Worker, assignments : Array[Assignment]) -> WorkerLoad

Compute a worker's load from schedule assignments.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io