🥮 mooncakes.io

rrule_lab

An explainable RFC 5545 recurrence rule engine written in MoonBit

calendar
rrule
rfc5545
scheduler
moon add cjkzD/rrule_lab@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
4 days ago
Downloads
2
README

#RRuleLab

CI License

RRuleLab 是一个使用 MoonBit 原创实现的、可解释且可审计的 RFC 5545 重复规则引擎。它把 RRULE、RDATE、EXDATE 转换为确定的时间序列，并进一步回答“规则为什么这样运行”“修改规则会影响哪些日期”“多个日程是否冲突”等问题。

项目面向日历、预约、排班、提醒、维护窗口和自动化任务。它不是 MoonBit 编译器周边工具，也不是普通 cron 解析器；核心差异在于 RFC 5545 语义、行为级差异分析和可解释日程审计。

#功能

  • 解析、校验、规范化并序列化 RFC 5545 RRULE
  • 支持 SECONDLY 到 YEARLY、主要 BY* 过滤器、负序号及 BYSETPOS
  • 在有界窗口内安全展开规则，带结果与迭代上限
  • 合并 DTSTART、多个 RRULE、RDATE 与 EXDATE
  • 读取与生成 recurrence 相关的 iCalendar/VEVENT 子集
  • 中英文规则解释、字段级诊断与修复建议
  • 比较两个规则的新增、删除、共有实例及首次分歧
  • 审计重复实例、周末、非工作时段、过密计划和间隔分布
  • 检测带持续时间事件的区间冲突，计算忙碌窗口与空闲窗口
  • ISO 8601 持续时间和节假日感知的业务日历调整
  • 可作为 MoonBit 库使用，也提供可运行 CLI

#五分钟开始

需要 MoonBit 工具链。在仓库根目录执行：

moon check
moon test
moon run cmd/rrule_lab -- demo

规范化并解释规则：

moon run cmd/rrule_lab -- normalize "RRULE:FREQ=WEEKLY;BYDAY=WE,MO,MO"
moon run cmd/rrule_lab -- explain "FREQ=MONTHLY;BYDAY=-1FR" zh

展开一个真实日程：

moon run cmd/rrule_lab -- expand \
  20260801T090000 \
  "FREQ=WEEKLY;COUNT=6;BYDAY=MO,WE,FR" \
  20260801T000000 \
  20260901T000000 \
  20

审计日程或比较规则变更：

moon run cmd/rrule_lab -- audit 20260801T080000 \
  "FREQ=DAILY;COUNT=5" 20260801T000000 20260810T000000

moon run cmd/rrule_lab -- diff 20260801T090000 \
  "FREQ=DAILY;COUNT=6" \
  "FREQ=DAILY;INTERVAL=2;COUNT=6" \
  20260801T000000 20260820T000000

完整命令列表：

moon run cmd/rrule_lab -- help

#库 API 示例

let start = @rrule_lab.parse_datetime("20260803T093000")
let rule = @rrule_lab.parse_rrule("FREQ=WEEKLY;COUNT=8;BYDAY=MO,WE,FR")
let options = @rrule_lab.ExpansionOptions::new(
  @rrule_lab.parse_datetime("20260801T000000"),
  @rrule_lab.parse_datetime("20260901T000000"),
  limit=20,
)
let occurrences = @rrule_lab.expand_rrule(start, rule, options)
let audit = @rrule_lab.audit_occurrences(occurrences)
println(audit.to_text())

在其他 MoonBit 项目中使用发布版本：

moon add cjkzD/rrule_lab

#工程质量

  • 主要实现语言：MoonBit
  • 有效 MoonBit 源码：4053 行（包含测试，不包含 _build）
  • 自动化测试：51 项，覆盖 Wasm 与 JavaScript 目标
  • CI：检查、测试、构建、格式、CLI 示例、代码规模门禁
  • 许可证：Apache-2.0；运行时仅依赖 MoonBit 官方 core
  • 开发记录：真实功能拆分提交，保留架构、变更与发布说明

#功能边界

首个版本专注本地日期时间与 recurrence 语义，不包含 CalDAV 同步、完整 IANA 时区数据库、自然语言模型解析或完整 iCalendar 全组件支持。浮动本地时间与时区换算明确分层，避免在规则运算中隐式引入环境差异。

更多信息见 架构设计、发布说明、更新日志 和 项目申报书。

#许可证

Copyright 2026 cjkzD。根据 Apache License 2.0 开源。

#
BusinessCalendarError

source
pub suberror BusinessCalendarError {
  EmptyWorkingWeek
  SearchLimitExceeded(Date, Int)
} derive(Eq, 
Debug)

#
CliError

source
pub suberror CliError {
  MissingArgument(String)
  InvalidNumber(String, String)
  UnknownCommand(String)
  InvalidLanguage(String)
} derive(Eq, 
Debug)

#
DateTimeError

source
pub suberror DateTimeError {
  InvalidDate(Int, Int, Int)
  InvalidTime(Int, Int, Int)
  InvalidFormat(String)
} derive(Eq, 
Debug)

#
DurationError

source
pub suberror DurationError {
  EmptyDuration
  MissingDesignator
  MissingNumber(Int)
  InvalidCharacter(Int, Int)
  DuplicateUnit(String)
  UnitOutOfOrder(String)
  DateUnitInTimePart(String)
  TimeUnitInDatePart(String)
  FractionUnsupported
  NonFixedCalendarUnit
} derive(Eq, 
Debug)

#
EventSlotError

source
pub suberror EventSlotError {
  NonPositiveDuration
} derive(Eq, 
Debug)

#
ExpansionError

source
pub suberror ExpansionError {
  InvalidRule(Array[Diagnostic])
  InvalidWindow
  InvalidLimit(Int)
  IterationLimitExceeded(Int)
} derive(
Debug)

#
ICalendarError

source
pub suberror ICalendarError {
  MissingStart
  InvalidContentLine(String)
  UnsupportedProperty(String)
  InvalidDateValue(String)
} derive(Eq, 
Debug)

#
RRuleParseError

source
pub suberror RRuleParseError {
  EmptyRule
  InvalidPart(String)
  DuplicateField(String)
  MissingFrequency
  UnknownFrequency(String)
  InvalidInteger(String, String)
  InvalidWeekday(String)
  InvalidUntil(String)
  InvalidValue(String, String)
} derive(Eq, 
Debug)

#
TimeRangeError

source
pub suberror TimeRangeError {
  EmptyOrReversedRange(DateTime, DateTime)
} derive(Eq, 
Debug)

#
AuditFinding

source
pub struct AuditFinding {
  severity : AuditSeverity
  code : String
  message : String
  evidence : Array[DateTime]
  suggestion : String
} derive(Eq, 
Debug)

A stable finding code plus human-readable evidence and remediation.

#
AuditSeverity

source
pub(all) enum AuditSeverity {
  AuditInfo
  AuditWarning
  AuditError
} derive(Compare, Eq, 
Debug)

Severity used by schedule audit findings.

#
AuditSeverity::label

source
fn AuditSeverity::label(self : AuditSeverity) -> String

#
BusinessCalendar

source
pub struct BusinessCalendar {
  name : String
  working_weekdays : Array[Weekday]
  holidays : Array[Date]
} derive(Eq, 
Debug)

Named workweek and holiday set. Dates are local calendar dates; no timezone assumptions are introduced by business-day adjustment.

#
BusinessCalendar::add_business_days

source
fn BusinessCalendar::add_business_days(self : BusinessCalendar, date : Date, amount : Int) -> Date raise BusinessCalendarError

#
BusinessCalendar::add_holiday

source
fn BusinessCalendar::add_holiday(self : BusinessCalendar, date : Date) -> BusinessCalendar

#
BusinessCalendar::adjust

source
fn BusinessCalendar::adjust(self : BusinessCalendar, date : Date, convention : BusinessDayConvention) -> Date raise BusinessCalendarError

#
BusinessCalendar::adjust_datetime

source

#
BusinessCalendar::adjust_occurrences

source
fn BusinessCalendar::adjust_occurrences(self : BusinessCalendar, values : Array[DateTime], convention : BusinessDayConvention, deduplicate? : Bool) -> Array[BusinessDayAdjustment] raise BusinessCalendarError

#
BusinessCalendar::count_business_days

source
fn BusinessCalendar::count_business_days(self : BusinessCalendar, start : Date, finish : Date) -> Int

Count working dates in the half-open interval [start, finish).

#
BusinessCalendar::is_holiday

source
fn BusinessCalendar::is_holiday(self : BusinessCalendar, date : Date) -> Bool

#
BusinessCalendar::is_working_day

source
fn BusinessCalendar::is_working_day(self : BusinessCalendar, date : Date) -> Bool

#
BusinessCalendar::new

source
fn BusinessCalendar::new(name : String, working_weekdays? : Array[Weekday], holidays? : Array[Date]) -> BusinessCalendar raise BusinessCalendarError

#
BusinessCalendar::next_working_date

source
fn BusinessCalendar::next_working_date(self : BusinessCalendar, date : Date, include_current? : Bool, search_limit? : Int) -> Date raise BusinessCalendarError

#
BusinessCalendar::previous_working_date

source
fn BusinessCalendar::previous_working_date(self : BusinessCalendar, date : Date, include_current? : Bool, search_limit? : Int) -> Date raise BusinessCalendarError

#
BusinessCalendar::remove_holiday

source
fn BusinessCalendar::remove_holiday(self : BusinessCalendar, date : Date) -> BusinessCalendar

#
BusinessCalendar::to_text

source
fn BusinessCalendar::to_text(self : BusinessCalendar) -> String

Describe the calendar in a stable, diff-friendly text format.

#
BusinessCalendar::with_working_weekdays

source
fn BusinessCalendar::with_working_weekdays(self : BusinessCalendar, working_weekdays : Array[Weekday]) -> BusinessCalendar raise BusinessCalendarError

#
BusinessCalendar::working_dates_between

source
fn BusinessCalendar::working_dates_between(self : BusinessCalendar, start : Date, finish : Date) -> Array[Date]

#
BusinessDayAdjustment

source
pub struct BusinessDayAdjustment {
  original : DateTime
  adjusted : DateTime
  changed : Bool
  convention : BusinessDayConvention
} derive(Eq, 
Debug)

#
BusinessDayConvention

source
pub(all) enum BusinessDayConvention {
  Unadjusted
  Following
  ModifiedFollowing
  Preceding
  ModifiedPreceding
} derive(Compare, Eq, 
Debug)

Convention used when an occurrence lands on a non-working date.

#
BusinessDayConvention::label

source
fn BusinessDayConvention::label(self : BusinessDayConvention) -> String

#
ByDay

source
pub struct ByDay {
  ordinal : Int?
  weekday : Weekday
} derive(Compare, Eq, 
Debug)

A weekday optionally qualified with an ordinal such as 1MO or -1FR.

#
ByDay::new

source
fn ByDay::new(weekday : Weekday, ordinal? : Int) -> ByDay

#
ByDay::to_string

source
fn ByDay::to_string(self : ByDay) -> String

#
ChangeImpact

source
pub struct ChangeImpact {
  baseline_count : Int
  candidate_count : Int
  added : Array[DateTime]
  removed : Array[DateTime]
  unchanged : Array[DateTime]
  first_divergence : DateTime?
  similarity_permille : Int
} derive(Eq, 
Debug)

Behavioral impact of replacing one rule with another over a finite horizon.

#
CliResult

source
pub struct CliResult {
  exit_code : Int
  stdout : String
  stderr : String
} derive(Eq, 
Debug)

#
Date

source
pub struct Date {
  year : Int
  month : Int
  day : Int
} derive(Compare, Eq, 
Debug)

A proleptic Gregorian calendar date.

#
Date::add_days

source
fn Date::add_days(self : Date, amount : Int) -> Date

#
Date::add_months

source
fn Date::add_months(self : Date, amount : Int) -> Date

#
Date::add_years

source
fn Date::add_years(self : Date, amount : Int) -> Date

#
Date::day_of_year

source
fn Date::day_of_year(self : Date) -> Int

#
Date::new

source
fn Date::new(year : Int, month : Int, day : Int) -> Date raise DateTimeError

#
Date::to_epoch_day

source
fn Date::to_epoch_day(self : Date) -> Int

Howard Hinnant's civil calendar conversion, shifted to Unix epoch days.

#
Date::to_iso_string

source
fn Date::to_iso_string(self : Date) -> String

#
Date::weekday

source
fn Date::weekday(self : Date) -> Weekday

#
DateTime

source
pub struct DateTime {
  date : Date
  time : Time
} derive(Compare, Eq, 
Debug)

A local date and time. RRuleLab deliberately keeps local time separate from time-zone conversion so recurrence arithmetic remains deterministic.

#
DateTime::add_days

source
fn DateTime::add_days(self : DateTime, amount : Int) -> DateTime

#
DateTime::add_duration

source
fn DateTime::add_duration(self : DateTime, duration : Duration) -> DateTime

#
DateTime::add_months

source
fn DateTime::add_months(self : DateTime, amount : Int) -> DateTime

#
DateTime::add_seconds

source
fn DateTime::add_seconds(self : DateTime, amount : Int64) -> DateTime

#
DateTime::add_years

source
fn DateTime::add_years(self : DateTime, amount : Int) -> DateTime

#
DateTime::new

source
fn DateTime::new(year : Int, month : Int, day : Int, hour : Int, minute : Int, second : Int) -> DateTime raise DateTimeError

#
DateTime::to_epoch_second

source
fn DateTime::to_epoch_second(self : DateTime) -> Int64

#
DateTime::to_iso_string

source
fn DateTime::to_iso_string(self : DateTime) -> String

#
Diagnostic

source
pub struct Diagnostic {
  severity : Severity
  code : String
  field : String
  message : String
  suggestion : String?
} derive(Eq, 
Debug)

Machine-readable and human-friendly diagnostic returned by validation.

#
Duration

source
pub struct Duration {
  years : Int
  months : Int
  weeks : Int
  days : Int
  hours : Int
  minutes : Int
  seconds : Int
  negative : Bool
} derive(Eq, 
Debug)

A calendar-aware ISO 8601 duration. Years and months are retained as calendar units; weeks, days and clock fields can also be reduced to seconds.

#
Duration::explain_en

source
fn Duration::explain_en(self : Duration) -> String

Produce a compact English explanation suitable for reports and CLI output.

#
Duration::explain_zh

source
fn Duration::explain_zh(self : Duration) -> String

#
Duration::fixed_seconds

source
fn Duration::fixed_seconds(self : Duration) -> Int64 raise DurationError

#
Duration::has_calendar_units

source
fn Duration::has_calendar_units(self : Duration) -> Bool

#
Duration::is_zero

source
fn Duration::is_zero(self : Duration) -> Bool

#
Duration::new

source
fn Duration::new(years? : Int, months? : Int, weeks? : Int, days? : Int, hours? : Int, minutes? : Int, seconds? : Int, negative? : Bool) -> Duration

#
Duration::sign

source
fn Duration::sign(self : Duration) -> Int

#
Duration::to_iso_string

source
fn Duration::to_iso_string(self : Duration) -> String

#
Duration::zero

source
fn Duration::zero() -> Duration

#
EventSlot

source
pub struct EventSlot {
  schedule : String
  ordinal : Int
  start : DateTime
  finish : DateTime
} derive(Eq, 
Debug)

One occurrence represented as a half-open [start, finish) interval.

#
ExpansionOptions

source
pub struct ExpansionOptions {
  window_start : DateTime
  window_end : DateTime
  limit : Int
  iteration_limit : Int
} derive(Eq, 
Debug)

Bounds and safety limits for a recurrence expansion request.

#
ExpansionOptions::new

source
fn ExpansionOptions::new(window_start : DateTime, window_end : DateTime, limit? : Int, iteration_limit? : Int) -> ExpansionOptions

#
Frequency

source
pub enum Frequency {
  Secondly
  Minutely
  Hourly
  Daily
  Weekly
  Monthly
  Yearly
} derive(Compare, Eq, 
Debug)

Frequency ordered from the smallest to the largest recurrence period.

#
Frequency::code

source
fn Frequency::code(self : Frequency) -> String

#
RRule

source
pub struct RRule {
  frequency : Frequency
  interval : Int
  count : Int?
  until : DateTime?
  week_start : Weekday
  by_second : Array[Int]
  by_minute : Array[Int]
  by_hour : Array[Int]
  by_day : Array[ByDay]
  by_month_day : Array[Int]
  by_year_day : Array[Int]
  by_week_number : Array[Int]
  by_month : Array[Int]
  by_set_position : Array[Int]
} derive(Eq, 
Debug)

A fully typed subset of RFC 5545 RECUR. Empty arrays mean that the corresponding BY rule is absent and DTSTART supplies the default.

#
RRule::explain_en

source
fn RRule::explain_en(self : RRule) -> String

#
RRule::explain_zh

source
fn RRule::explain_zh(self : RRule) -> String

#
RRule::is_valid

source
fn RRule::is_valid(self : RRule) -> Bool

#
RRule::new

source
fn RRule::new(frequency : Frequency) -> RRule

#
RRule::normalize

source
fn RRule::normalize(self : RRule) -> RRule

#
RRule::to_string

source
fn RRule::to_string(self : RRule) -> String

#
RRule::validate

source
fn RRule::validate(self : RRule) -> Array[Diagnostic]

#
RecurrenceSet

source
pub struct RecurrenceSet {
  start : DateTime
  rules : Array[RRule]
  include_dates : Array[DateTime]
  exclude_dates : Array[DateTime]
} derive(Eq, 
Debug)

A calendar recurrence set combines one or more rules and explicit dates, then removes exception dates. This mirrors RFC 5545 recurrence semantics.

#
RecurrenceSet::add_date

source
fn RecurrenceSet::add_date(self : RecurrenceSet, value : DateTime) -> RecurrenceSet

#
RecurrenceSet::add_rule

source
fn RecurrenceSet::add_rule(self : RecurrenceSet, rule : RRule) -> RecurrenceSet

#
RecurrenceSet::exclude_date

source
fn RecurrenceSet::exclude_date(self : RecurrenceSet, value : DateTime) -> RecurrenceSet

#
RecurrenceSet::expand

source

#
RecurrenceSet::new

source

#
RecurrenceSet::to_ical

source
fn RecurrenceSet::to_ical(self : RecurrenceSet, uid? : String) -> String

#
RuleDifference

source
pub struct RuleDifference {
  only_left : Array[DateTime]
  only_right : Array[DateTime]
  shared : Array[DateTime]
} derive(Eq, 
Debug)

#
ScheduleAudit

source
pub struct ScheduleAudit {
  occurrence_count : Int
  unique_count : Int
  duplicate_count : Int
  weekend_count : Int
  outside_business_hours_count : Int
  first_occurrence : DateTime?
  last_occurrence : DateTime?
  minimum_gap_seconds : Int64?
  maximum_gap_seconds : Int64?
  average_gap_seconds : Int64?
  longest_daily_streak : Int
  weekday_histogram : WeekdayHistogram
  findings : Array[AuditFinding]
} derive(Eq, 
Debug)

Summary metrics and findings produced for one expanded recurrence set.

#
ScheduleAudit::to_text

source
fn ScheduleAudit::to_text(self : ScheduleAudit) -> String

Stable plain-text report intended for terminals, issues and CI logs.

#
ScheduleCollision

source
pub struct ScheduleCollision {
  left : EventSlot
  right : EventSlot
  overlap_start : DateTime
  overlap_finish : DateTime
  overlap_seconds : Int64
} derive(Eq, 
Debug)

#
SetOperation

source
pub(all) enum SetOperation {
  Union
  Intersection
  Difference
} derive(Eq, 
Debug)

#
Severity

source
pub(all) enum Severity {
  Error
  Warning
  Information
} derive(Compare, Eq, 
Debug)

#
Time

source
pub struct Time {
  hour : Int
  minute : Int
  second : Int
} derive(Compare, Eq, 
Debug)

Clock time without a time-zone offset.

#
Time::new

source
fn Time::new(hour : Int, minute : Int, second : Int) -> Time raise DateTimeError

#
Time::to_iso_string

source
fn Time::to_iso_string(self : Time) -> String

#
TimeRange

source
pub struct TimeRange {
  start : DateTime
  finish : DateTime
} derive(Eq, 
Debug)

Half-open time range [start, finish). This representation makes adjacent windows composable without double-counting their shared endpoint.

#
TimeRange::contains

source
fn TimeRange::contains(self : TimeRange, value : DateTime) -> Bool

#
TimeRange::duration_seconds

source
fn TimeRange::duration_seconds(self : TimeRange) -> Int64

#
TimeRange::intersection

source
fn TimeRange::intersection(self : TimeRange, other : TimeRange) -> TimeRange?

#
TimeRange::is_adjacent

source
fn TimeRange::is_adjacent(self : TimeRange, other : TimeRange) -> Bool

#
TimeRange::merge

source
fn TimeRange::merge(self : TimeRange, other : TimeRange) -> TimeRange?

#
TimeRange::new

source
fn TimeRange::new(start : DateTime, finish : DateTime) -> TimeRange raise TimeRangeError

#
TimeRange::overlaps

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

#
TimeRange::to_text

source
fn TimeRange::to_text(self : TimeRange) -> String

#
Weekday

source
pub enum Weekday {
  Monday
  Tuesday
  Wednesday
  Thursday
  Friday
  Saturday
  Sunday
} derive(Compare, Eq, 
Debug)

Days of the week use ISO order (Monday first).

#
Weekday::code

source
fn Weekday::code(self : Weekday) -> String

#
Weekday::iso_number

source
fn Weekday::iso_number(self : Weekday) -> Int

#
WeekdayHistogram

source
pub struct WeekdayHistogram {
  monday : Int
  tuesday : Int
  wednesday : Int
  thursday : Int
  friday : Int
  saturday : Int
  sunday : Int
} derive(Eq, 
Debug)

Distribution of recurrence instances over ISO weekdays.

#
WeekdayHistogram::empty

source

#
WeekdayHistogram::total

source
fn WeekdayHistogram::total(self : WeekdayHistogram) -> Int

#
WeekdayHistogram::weekend_total

source
fn WeekdayHistogram::weekend_total(self : WeekdayHistogram) -> Int

#
analyze_rule_change

source
fn analyze_rule_change(start : DateTime, baseline : RRule, candidate : RRule, options : ExpansionOptions) -> ChangeImpact raise ExpansionError

Compare rule behavior using occurrence sets rather than textual syntax.

#
audit_occurrences

source
fn audit_occurrences(values : Array[DateTime], business_start_hour? : Int, business_end_hour? : Int, expected_minimum? : Int, dense_gap_threshold_seconds? : Int64) -> ScheduleAudit

Analyze concrete occurrence data and return reproducible findings.

#
audit_rule

source
fn audit_rule(start : DateTime, rule : RRule, options : ExpansionOptions, business_start_hour? : Int, business_end_hour? : Int) -> ScheduleAudit raise ExpansionError

Expand and audit a recurrence rule in one bounded operation.

#
business_day_convention_from_string

source
fn business_day_convention_from_string(text : String) -> BusinessDayConvention?

#
cli_help

source
fn cli_help() -> String

#
combine_occurrences

source
fn combine_occurrences(left : Array[DateTime], right : Array[DateTime], operation : SetOperation) -> Array[DateTime]

#
compare_rules

source
fn compare_rules(start : DateTime, left : RRule, right : RRule, options : ExpansionOptions) -> RuleDifference raise ExpansionError

#
date_from_epoch_day

source
fn date_from_epoch_day(epoch_day : Int) -> Date

#
days_in_month

source
fn days_in_month(year : Int, month : Int) -> Int

#
detect_collisions

source
fn detect_collisions(left : Array[EventSlot], right : Array[EventSlot]) -> Array[ScheduleCollision]

Detect interval collisions between two named schedules. Touching endpoints are not collisions because event slots use half-open interval semantics.

#
duration_between

source
fn duration_between(start : DateTime, finish : DateTime) -> Duration

#
execute_cli

source
fn execute_cli(args : Array[String]) -> CliResult

Execute one CLI command without performing process I/O. This design makes the command interface fully testable and portable across Wasm and JS.

#
expand

source
fn expand(start : DateTime, rule_source : String, window_start : DateTime, window_end : DateTime, limit? : Int) -> Array[DateTime] raise

#
expand_rrule

source
fn expand_rrule(start : DateTime, rule : RRule, options : ExpansionOptions) -> Array[DateTime] raise ExpansionError

Expand a recurrence within a half-open time window [start, end).

#
free_time_ranges

source
fn free_time_ranges(bounds : TimeRange, busy : Array[TimeRange]) -> Array[TimeRange]

Find free half-open windows inside bounds after normalizing busy ranges.

#
frequency_from_code

source
fn frequency_from_code(code : String) -> Frequency?

#
is_leap_year

source
fn is_leap_year(year : Int) -> Bool

#
make_event_slots

source
fn make_event_slots(schedule : String, starts : Array[DateTime], duration : Duration) -> Array[EventSlot] raise

#
merge_time_ranges

source
fn merge_time_ranges(values : Array[TimeRange], merge_adjacent? : Bool) -> Array[TimeRange]

Merge overlapping ranges and, by default, directly adjacent ranges.

#
parse_basic_date

source
fn parse_basic_date(text : String) -> Date raise DateTimeError

#
parse_date

source
fn parse_date(text : String) -> Date raise DateTimeError

#
parse_datetime

source
fn parse_datetime(text : String) -> DateTime raise DateTimeError

#
parse_duration

source
fn parse_duration(source : String) -> Duration raise DurationError

Parse the integer subset of ISO 8601 durations, including leading minus. Supported examples include P2W, P1Y2M3DT4H5M6S and -PT90S.

#
parse_ical_recurrence

source
fn parse_ical_recurrence(source : String) -> RecurrenceSet raise

Parse the recurrence-related subset of an iCalendar component.

#
parse_rrule

source
fn parse_rrule(source : String) -> RRule raise RRuleParseError

Parse an RFC 5545 recurrence rule. The optional RRULE: prefix is accepted.

#
parse_time

source
fn parse_time(text : String) -> Time raise DateTimeError

#
ranges_total_seconds

source
fn ranges_total_seconds(values : Array[TimeRange]) -> Int64

#
version

source
fn version() -> String

Return the semantic version of the RRuleLab library.

#
weekday_from_code

source
fn weekday_from_code(code : String) -> Weekday?

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io