education.school-year-group

pub fn school_year_group(birth_date: &str, on_date: &str, nation: &str) -> SchoolYearGroup

// UkNation is a string in Rust, one of: "england", "wales", "scotland", "northern-ireland".
// Parameters take it as &str and results hold it as String.

/// Where a child of that age sits in the school system on a date.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SchoolYearGroup {
    /// first day of the school year containing onDate, for this calculation
    pub school_year_start: String,
    /// calendar year the child's cohort starts Reception or P1
    pub entry_year: i64,
    /// years since that start: 0 is Reception or P1, negative before it
    pub index: i64,
    /// Reception, Year 1 ... Year 13; P1 ... S6; P1 ... Year 14; null before or after school
    pub year_group: Option<String>,
    /// primary or secondary; null when yearGroup is
    pub stage: Option<String>,
}

fune!(education.school-year-group@^1);  // then call school_year_group(…)

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::dates_add_days::parse_iso_date;  ← from dates.add-days ^1.0.0 · built alongside by fune
use super::education_school_year_group_data::{COHORT_RULES, YEAR_GROUPS};  ← this capability’s own data, compiled from data/cohort-rules.json into the same file by fune build

/// The year group a child is in on a date, placed by their birth date.
///
/// The cohort comes from the birth date itself (born on or after the cohort
/// start joins a year later), never from an age on a cut-off date, which
/// misplaces 29 February births where the cohort starts on 1 March.
///
/// # Panics
/// Panics on a malformed date, onDate before birthDate, or an unknown nation.
pub fn school_year_group(birth_date: &str, on_date: &str, nation: &str) -> SchoolYearGroup {
    let birth = parse_iso_date(birth_date);
    let on = parse_iso_date(on_date);
    if on_date < birth_date {
        panic!("onDate {} is before birthDate {}", on_date, birth_date);
    }
    let rule = match COHORT_RULES.iter().find(|r| r.nation == nation) {
        Some(r) => r,
        None => panic!("unknown nation \"{}\": use england, wales, scotland or northern-ireland", nation),
    };
    let entry_year = birth.year + rule.entry_age + if &birth_date[5..] >= rule.cohort_start { 1 } else { 0 };
    let start_year = if &on_date[5..] >= rule.school_year_start { on.year } else { on.year - 1 };
    let index = start_year - entry_year;
    let name = YEAR_GROUPS.iter().find(|g| g.nation == nation && g.index == index);
    SchoolYearGroup {
        school_year_start: format!("{:04}-{}", start_year, rule.school_year_start),
        entry_year,
        index,
        year_group: name.map(|g| g.label.to_string()),
        stage: name.map(|g| g.stage.to_string()),
    }
}

pub fn school_year_group_to_value(g: &SchoolYearGroup) -> Value {
    let opt = |v: &Option<String>| match v {
        Some(s) => Value::str(s),
        None => Value::Null,
    };
    Value::obj(vec![
        ("schoolYearStart", Value::str(&g.school_year_start)),
        ("entryYear", Value::Int(g.entry_year)),
        ("index", Value::Int(g.index)),
        ("yearGroup", opt(&g.year_group)),
        ("stage", opt(&g.stage)),
    ])
}

pub fn fune_vector(args: &[Value]) -> Value {
    school_year_group_to_value(&school_year_group(args[0].as_str(), args[1].as_str(), args[2].as_str()))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and its 1 dependency, pins them in fune.lock, downloads only the Rust package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. A crate’s build.rs runs it before every compile. Or pin a range in fune.project and build in one step:

fune add education.school-year-group

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./education.school-year-group-1.0.1-rust.fune, or fetch it from a terminal with fune pull education.school-year-group@1.0.1:rust.

The whole function, every language, is one file too: education.school-year-group-1.0.1.fune, 25,255 bytes, sha256 f3210b5447a1609ada7aa234b73029f9222291daf2c7c1cdc506f4556ffe4ef4. It installs into a project of any language.

// fune: before education.school-year-group

// fune: after education.school-year-group

// fune: replace dates.add-days in education.school-year-group

// fune: step education.school-year-group after <n|label>

More from the author

## How it works, and the leap-day trap

The cohort is decided from the birth date itself: a child born on or after the nation's cohort start date (1 September, 1 March, 2 July) joins the class that starts the year after four years on; one born before it, the year before. The school year containing `onDate` then gives how many years along they are.

Working from the child's *age* on a cut-off date instead goes wrong on 29 February in Scotland: a child born 29 February 2020 is in the cohort born 1 March 2019 to 29 February 2020, but has the same age as the 1 March 2020 children on every late-February date in later years (a birthday of 29 February counts as 1 March in common years). A vector pins it.

## Decisions

- **School year boundaries** are 1 September (England, Wales, Northern Ireland) and 1 August (Scotland, whose schools go back mid-August; each council sets the exact day). A date between that boundary and the first day of term is placed in the new year group. - `index` is always returned; `yearGroup` is null before Reception or P1 (nursery and pre-school are not named) and after the last year. - Deferred entry (Scotland's January and February births, summer-born children in England, Northern Ireland's 1 April to 1 July births) and children educated out of their year group are the caller's to apply: shift `index` by the years deferred. - The rules are long-standing conventions rather than dated rates, so the tables carry no `effective` columns and always ship whole.

## Sources

- GOV.UK, "School admissions: school starting age" ("Most children start reception full-time in September after their fourth birthday"): https://www.gov.uk/schools-admissions/school-starting-age - mygov.scot, "Choosing a school for your child", and Education Scotland Parentzone, "Starting school" (a year group is born between the start of March and the end of February; P1 starts in August): https://www.mygov.scot/register-your-child-for-a-school , https://education.gov.scot/parentzone/my-child/transitions/starting-school - nidirect, "Deferral of pre-school or primary school places", and Department of Education NI, "Compulsory education" (children aged 4 on or before 1 July start P1 that September): https://www.nidirect.gov.uk/articles/deferral-pre-school-or-primary-school-places , https://www.education-ni.gov.uk/articles/compulsory-education

## Notices

Contains public sector information licensed under the Open Government Licence v3.0 (https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/).

1.0.1 adds its attribution notices (NOTICE). The code and the tests are unchanged.

Files