RSL at a glance

Install Relativities and download the synthetic examples before running this page. This page shows how to read and write each part of a rater. It uses the dwelling fire rater from Write your first rater, plus two small raters for the forms that rater skips.

The parts of a rater file

A rater file holds a fixed set of blocks, in this order. Each block matches a part of the rating manual.

Block	Holds	In the manual
`spec`	the carrier, state, product and effective date	the cover page
`Sources`	the filed documents that the rater cites	the filing itself
`Types`	the names and value sets that the manual uses	the definitions
`Constants`	single filed numbers, such as a policy fee	a fee or a factor in the text
`Tables`	the filed rate tables	the rate pages
`Records`	the facts of a policy, its rules and its calculations	the rating steps
`RatingOutcomes`	the values that the rater returns, such as the premium	the final premium

The spec block also holds the language version line. Copy it as the tutorial shows. A line that starts with # is a comment.

Name the values the manual uses

The Types block names the sets of values that the manual uses:

Types = {
    Peril = {
        fire,
        wind,
        theft
    },
    ProtectionClass = IntBands(1, 4, 7, 10..),
    Money = Num {precision: 0.01}
}

An enum lists named choices, such as the perils. A request sends a member by its name.
A band type groups numbers into ranges. IntBands(1, 4, 7, 10..) makes the bands 1 to 3, 4 to 6, 7 to 9, and 10 and up.
A number type gives a precision. Money holds whole cents.

An enum member can have a different name in a request. fire_resistive = "fire-resistive" makes a request send "fire-resistive":

    Construction = {
        frame,
        masonry,
        fire_resistive = "fire-resistive"
    },

Premium, Factor and Rate are built-in number types. Use them for premiums, multipliers and rates.

Declare the inputs

The inputs are the facts that a request sends. Each input has a type and, for a number, a range. This rater shows each kind of input:

        inputs {
            term_months: Num {precision: int} where self in [6, 12] and self in {6, 12},
            effective: Date where self in [2026-01-01, 2027-12-31],
            coverage_a: Num {precision: 1000} where self in [50000, 2000000],
            construction: Construction,
            sprinklered: Bool,
            prior_claims: Option(ClaimCount),
            buildings: List(Building) keyed by number
                where len(self) in [1, 5] [code: "BUILDING-COUNT", message: "A policy covers one to five buildings.", cite: manual:p5]
        },

Type	A request sends
`Num {precision: int}`	a whole number
`Num {precision: 1000}`	a multiple of 1,000
`Date`	a date as a `"YYYY-MM-DD"` string
`Bool`	`true` or `false`
An enum	the name of a member, as a string
`Option(T)`	a value of type `T`, or `null` when it is unknown
`List(R)`	a list of records of type `R`
A record	a JSON object with that record’s inputs

keyed by number makes each building’s number unique in its list. Each Option input needs a match with a None arm and a Some arm before a calculation uses it.

Add rules to the inputs

A rule is a where clause. The rater checks every rule before it calculates, and refuses a request that breaks one.

Rule	Accepts
`where self in [a, b]`	`a` to `b`, both included
`where self in (a, b]`	above `a`, up to `b`
`where self in [a, _]`	`a` and above
`where self in {6, 12}`	only the values in the set
`where len(self) in [1, 5]`	a list with one to five elements

Each number input needs a range. The range tells the check which values to prove the calculations for. A rule from the filing gets a code, a message and a citation in brackets. The refusal carries all three. A rule that reads several inputs goes after the record’s closing brace:

    } where self.coverage_a in [_, 1000000] or self.sprinklered [code: "SPRINKLER-REQUIRED", message: "A dwelling over 1,000,000 needs sprinklers.", cite: manual:p5],

The sample download includes this rater in relativities-examples/rsl/inputs. Rate one good request and one that breaks two rules:

import json

import rslc

rater = rslc.PreparedRater("relativities-examples/rsl/inputs")
policy = {
    "Policy": {
        "term_months": 12,
        "effective": "2026-03-01",
        "coverage_a": 300000,
        "construction": "fire-resistive",
        "sprinklered": False,
        "prior_claims": 1,
        "buildings": [{"number": 1}],
    }
}
print(rater.rate(json.dumps(policy)))
# {"ok":true,"outputs":{"Policy":{"buildings":[{}],"premium":862}}}
policy["Policy"].update(coverage_a=1200000, construction="fire_resistive", prior_claims=None)
print(rater.rate(json.dumps(policy)))
# {"ok":false,"refusal":{"error":"BusinessRejection","truncated":false,"violations":[{"cite":null,"code":"INPUT-ENUM","constraint":"construction: Enum(Construction)","message":"construction must be one of: frame, masonry, fire-resistive","path":"Policy.construction","value":"fire_resistive"},{"cite":"manual:p5","code":"SPRINKLER-REQUIRED","constraint":"Policy where self.coverage_a in [_, 1000000] or self.sprinklered","message":"A dwelling over 1,000,000 needs sprinklers.","path":"Policy","value":{"coverage_a":1200000,"sprinklered":false}}]}}

The second request breaks two rules, and the refusal lists both. Refusals describes each part of a refusal.

Write the calculations

A step block holds calculations. Each calculation has a name, a type, often a citation, and a formula after =:

        step premium {
            peril_premium[p: Peril]: Premium [cite: manual:p8] =
                round(self.dwelling.coverage_a / 1000 * lookup!(BaseRate, self.dwelling.protection_class).rate[p], 2, half_up),
            item_charge: Premium [cite: manual:p6] = sum(self.items as i, i.charge),
            premium: Premium [cite: manual:p9] =
                round(sum(Peril as p, self.peril_premium[p]) + self.item_charge + expense_fee, 0, half_up)
        }

self.dwelling.coverage_a reads an input of the record, or of a record inside it.
+, -, * and / do arithmetic on exact decimals.
sum(self.items as i, i.charge) adds a value over each item of a list. product, min, max, avg and count work the same way.
sum(Peril as p, ...) adds a value over each member of an enum.
The order of the calculations is free. The rater works out the order from what each formula reads.

Choose a value

if picks between two values. match picks one value for each member of an enum, or for each case of an Option:

            construction_factor: Factor [cite: manual:p7] =
                match self.construction {
                    @Construction.frame => 1.2,
                    @Construction.masonry => 1,
                    @Construction.fire_resistive => 0.9
                },
            claim_charge: Premium [cite: manual:p8] =
                match self.prior_claims {
                    None => 0,
                    Some(n) => 25 * n
                },

@Construction.frame names a member of the Construction enum. A match lists every case.

Keep one value per peril

peril_premium[p: Peril] is a map: one value for each member of Peril. Read one value with self.peril_premium[p]. A rater returns a map as a JSON object keyed by member. A map can cover only some members. This rater gives a deductible credit to fire and wind only:

    PropertyPeril = Peril where self in {@Peril.fire, @Peril.wind},

            deductible_credit[p: PropertyPeril]: Factor [cite: manual:p5] =
                match p {
                    @Peril.fire => if self.deductible >= 2500 then 0.9 else 1,
                    @Peril.wind => if self.deductible >= 2500 then 0.85 else 1
                },
            peril_premium[p: Peril]: Premium [cite: manual:p8] =
                round(self.coverage_a / 1000 * lookup!(BaseRate, self.protection_class).rate[p] * (if p in PropertyPeril then self.deductible_credit[p] else 1), 2, half_up),

if p in PropertyPeril reads the credit only for fire and wind. The sample download includes this rater in relativities-examples/rsl/maps:

rater = rslc.PreparedRater("relativities-examples/rsl/maps")
policy = {"Policy": {"coverage_a": 250000, "protection_class": 5, "deductible": 2500}}
print(rater.rate(json.dumps(policy), detailed=True))
# {"ok":true,"outputs":{"Policy":{"premium":868,"deductible_credit":{"fire":0.9,"wind":0.85},"peril_premium":{"fire":585,"wind":170,"theft":112.5}}}}

Read a table

A table declares its key columns after dims and its output columns after ->. Its rows live in a CSV file named after the table:

    BaseRate [cite: manual:p3] :
        table dims (protection: ProtectionClass) -> {
            rate: Rate[Peril]
        }
        columns: {
            rate[fire]: "fire",
            rate[wind]: "wind",
            rate[theft]: "theft"
        }

lookup!(BaseRate, self.dwelling.protection_class) finds the row for a key. .rate[p] reads one peril’s rate from it. Read a filed table covers tables with more keys and rows the filing leaves out.

Round where the manual rounds

round(x, 0, half_up) rounds to whole dollars, with halves going up. The second number counts decimal places, and the third names the rounding mode. RSL rounds only where a round says so. Round a premium lists the modes.

Cite the filing

Each filed number cites the place in the filing that prints it. [cite: manual:p3] points to page 3 of the manual source. Tables, constants and rounding calculations each need one. Citations explains the rules.

Name the outcome

RatingOutcomes names the values that the rater returns. At least one of them is a Premium calculation that rounds:

RatingOutcomes = {
    premium: Policy.premium
}

What rslc checks and guarantees explains what the check proves about these forms.
Check messages lists each message that rslc check prints.

Get started

Comparative pricing

Prepare and validate

Concepts

Rater development

Python reference

Data reference

The parts of a rater file

Name the values the manual uses

Declare the inputs

Add rules to the inputs

Write the calculations

Choose a value

Keep one value per peril

Read a table

Round where the manual rounds

Cite the filing

Name the outcome

​The parts of a rater file

​Name the values the manual uses

​Declare the inputs

​Add rules to the inputs

​Write the calculations

​Choose a value

​Keep one value per peril

​Read a table

​Round where the manual rounds

​Cite the filing

​Name the outcome

​Related

The parts of a rater file

Name the values the manual uses

Declare the inputs

Add rules to the inputs

Write the calculations

Choose a value

Keep one value per peril

Read a table

Round where the manual rounds

Cite the filing

Name the outcome

Related