energy.price-cap

priceCap("electricity", "direct-debit", "2026-05-01")
  -> unitRate 24670 (24.67p/kWh), standingCharge 57210 (57.21p/day), vatBasisPoints 500

pub fn price_cap(fuel: &str, payment_method: &str, on_date: &str) -> PriceCap

// EnergyFuel is a string in Rust, one of: "electricity", "gas".
// Parameters take it as &str and results hold it as String.

// PaymentMethod is a string in Rust, one of: "direct-debit", "standard-credit", "prepayment".
// Parameters take it as &str and results hold it as String.

/// The capped rates for one cap period, as Ofgem publishes them.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PriceCap {
    pub fuel: String,
    pub payment_method: String,
    /// GB: the England, Scotland and Wales average
    pub region: String,
    /// thousandths of a penny per kWh: 24.67p is 24670
    pub unit_rate: i64,
    /// thousandths of a penny per day: 57.21p is 57210
    pub standing_charge: i64,
    /// VAT included in both figures: 500, or 0 where none applied
    pub vat_basis_points: i64,
    /// first day of the cap period
    pub valid_from: String,
    /// last day of the cap period
    pub valid_to: String,
}

fune!(energy.price-cap@^1);  // then call price_cap(…)

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::energy_price_cap_data::{PRICE_CAP, PRICE_CAP_HISTORY};  ← this capability’s own data, compiled from data/price-cap.json into the same file by fune build

fn is_iso_date(value: &str) -> bool {
    let bytes = value.as_bytes();
    bytes.len() == 10
        && bytes[4] == b'-'
        && bytes[7] == b'-'
        && bytes.iter().enumerate().all(|(i, b)| i == 4 || i == 7 || b.is_ascii_digit())
}

/// The Ofgem price cap unit rate and standing charge in force on `on_date`.
///
/// # Panics
/// Panics on a malformed date, an unknown fuel or payment method, a payment
/// method with no figures, or a date outside every period carried.
pub fn price_cap(fuel: &str, payment_method: &str, on_date: &str) -> PriceCap {
    if !is_iso_date(on_date) {
        panic!("onDate must be an ISO date (YYYY-MM-DD), received \"{}\"", on_date);
    }
    if fuel != "electricity" && fuel != "gas" {
        panic!("unknown fuel \"{}\": expected electricity or gas", fuel);
    }
    if !["direct-debit", "standard-credit", "prepayment"].contains(&payment_method) {
        panic!(
            "unknown payment method \"{}\": expected direct-debit, standard-credit or prepayment",
            payment_method
        );
    }
    let rows: Vec<_> = PRICE_CAP
        .iter()
        .filter(|r| r.fuel == fuel && r.payment_method == payment_method)
        .collect();
    if rows.is_empty() {
        panic!(
            "no price cap figures for {} paid by {}: this version carries GB-average Direct Debit figures only",
            fuel, payment_method
        );
    }
    let row = match rows.iter().find(|r| r.valid_from <= on_date && on_date <= r.valid_to) {
        Some(row) => row,
        None => {
            // A pruned build must not answer an old date with a newer cap.
            if PRICE_CAP_HISTORY != "full" {
                let earliest = rows.iter().map(|r| r.valid_from).min().unwrap();
                if on_date < earliest {
                    panic!(
                        "no price cap for {}/{} on {}: this build was installed with history={}, so it only carries periods from {}. Reinstall with history=full for older dates.",
                        fuel, payment_method, on_date, PRICE_CAP_HISTORY, earliest
                    );
                }
            }
            panic!("no price cap for {}/{} on {}", fuel, payment_method, on_date)
        }
    };
    PriceCap {
        fuel: fuel.to_string(),
        payment_method: payment_method.to_string(),
        region: row.region.to_string(),
        unit_rate: row.unit_rate,
        standing_charge: row.standing_charge,
        vat_basis_points: row.vat_basis_points,
        valid_from: row.valid_from.to_string(),
        valid_to: row.valid_to.to_string(),
    }
}

pub fn price_cap_to_value(p: &PriceCap) -> Value {
    Value::obj(vec![
        ("fuel", Value::str(&p.fuel)),
        ("paymentMethod", Value::str(&p.payment_method)),
        ("region", Value::str(&p.region)),
        ("unitRate", Value::Int(p.unit_rate)),
        ("standingCharge", Value::Int(p.standing_charge)),
        ("vatBasisPoints", Value::Int(p.vat_basis_points)),
        ("validFrom", Value::str(&p.valid_from)),
        ("validTo", Value::str(&p.valid_to)),
    ])
}

pub fn fune_vector(args: &[Value]) -> Value {
    price_cap_to_value(&price_cap(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 nothing else, 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 energy.price-cap

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./energy.price-cap-1.0.2-rust.fune, or fetch it from a terminal with fune pull energy.price-cap@1.0.2:rust.

The whole function, every language, is one file too: energy.price-cap-1.0.2.fune, 27,981 bytes, sha256 b5ceea9f411ec53104d7e2ca1a14be3bffe7b245a623d40c0148b2e68f993042. It installs into a project of any language.

// fune: before energy.price-cap

// fune: after energy.price-cap

// fune: step energy.price-cap after <n|label>

More from the author

## Scope of the data

- **GB average, Direct Debit, single-rate electricity.** These are the figures Ofgem publishes as the headline cap for each period: the average across England, Scotland and Wales for a customer paying by Direct Debit. Nine periods, **1 October 2024 to 31 December 2026**. - **Not regional.** The cap differs by the 14 electricity regions. Ofgem publishes the regional rates only in its interactive tables and spreadsheets, which this version does not carry; a regional bill needs the supplier's own rates (which may be below the cap anyway). - **Not standard credit or prepayment.** The types list them because the cap is set for each, but Ofgem does not publish GB-average unit rates for them in a form that could be checked here, so asking for one is an error rather than a guess. They will be new rows, not new code. - **Not Economy 7 / multi-rate.** Ofgem caps a multi-register meter as a whole rather than publishing a GB-average day and night rate.

## Units and VAT

Rates are integers in **thousandths of a penny**, matching the rest of the `energy.*` capabilities (`energy.tariff-time-of-use`, `energy.bill-calculate`); Ofgem's figures are rounded to two decimal places, so the last digit is always 0.

The figures **include VAT**, and `vatBasisPoints` says how much: 5% on everything, except electricity from 1 October 2026, which the government zero-rated for domestic customers in Great Britain from 1 October 2026 to 31 March 2027 (Ofgem: "It does not include VAT from 1 October 2026 to 31 March 2027"). To get the pre-VAT rate for a bill, divide by `1 + vatBasisPoints / 10000`.

## Dates

A period runs `validFrom` to `validTo` inclusive (calendar quarters). A date outside every period this version carries is an error: the cap for a period not yet announced is not today's cap. A build installed with `history=current` keeps only periods still running and refuses older dates with an explanation.

## Sources

Ofgem news releases, "Changes to energy price cap between ..." (each gives the Direct Debit GB-average unit rate and standing charge for electricity and gas, and states the VAT they include):

- 1 January to 31 March 2026: https://www.ofgem.gov.uk/news/changes-energy-price-cap-between-1-january-and-31-march-2026 - 1 April to 30 June 2026: https://www.ofgem.gov.uk/news/changes-energy-price-cap-between-1-april-and-30-june-2026 - 1 July to 30 September 2026: https://www.ofgem.gov.uk/news/changes-energy-price-cap-between-1-july-and-30-september-2026 - 1 October to 31 December 2026: https://www.ofgem.gov.uk/news/changes-energy-price-cap-between-1-october-and-31-december-2026

Ofgem, "Energy price cap" consumer page, as archived by the Internet Archive (https://web.archive.org/web/2025*/https://www.ofgem.gov.uk/information-consumers/energy-advice-households/energy-price-cap) in February, May, August and November 2025, each showing the current and next period: October to December 2024, and each quarter of 2025.

Ofgem, "Energy price cap (default tariff) levels", https://www.ofgem.gov.uk/energy-regulation/domestic-and-non-domestic/energy-pricing-rules/energy-price-cap/energy-price-cap-default-tariff-levels (the regional and per-payment-method models this version does not carry).

1.0.1 fixes Python accepting a trailing newline or non-ASCII digits in onDate; adds tests.

## Notices

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

Source: Ofgem (Crown copyright), reused under the Open Government Licence v3.0.

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

Files