RSL at a glance

An RSL file describes the facts a rater accepts, the rules it applies, and the calculations it returns. Most excerpts quote the synthetic dwelling-fire rater from Write your first rater. The tutorial contains the complete runnable source. Every rater starts with a spec block. It names the RSL version, the carrier, the state, the product, and the effective date:

spec {
    rsl: "0.4.1",
    carrier: "Example Mutual",
    state: AZ,
    product: "Dwelling Fire (tutorial)",
    effective_date: 2026-01-01
}

rslc reads RSL 0.4 and 0.4.1. A file that declares another version gets one E-RSL-VERSION message. Versions explains the two.

File structure

A rater is a sequence of sections. Most raters use these, in this order:

Section	Purpose
`spec`	Identify the carrier, product, state, effective date, and RSL version
`Sources`	Identify the documents cited by the rater
`Types`	Define named types and allowed values
`Constants`	Define fixed values, such as a policy fee
`Tables`	Declare rating tables
`Stages`	Name the stages of the rating manual (optional)
`Records`	Define inputs, rules, and calculations
`RatingOutcomes`	Select the results the rater returns

The order is a convention: the compiler reads the sections in any order. Lines beginning with # are comments. Other sections serve other files, such as import for a split rater and use, Roles and Acts for a guideline. Sections, types and annotations lists every section. Files and versions in the language reference states the rules of a file.

Types and inputs

The Types block defines names used throughout the rater:

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

Peril lists named choices.
ProtectionClass defines bands starting at 1, 4, 7, and 10.
Money represents amounts in whole cents.

An inputs block declares the facts supplied to a record:

inputs {
    dwelling: Dwelling,
    items: List(Item)
        where len(self) in [0, 10] [code: "TOO-MANY-ITEMS", message: "A policy schedules at most ten items.", cite: manual:p6]
},

Here, a policy contains one dwelling and a list of up to ten scheduled items.

Common input types

Type	Input value
`Num {precision: int}`	A whole number
`Bool`	`true` or `false`
`Date`	A calendar day, sent as `"2026-01-01"`
An enum	A named choice, sent as a string
`Code(pattern: "...")`	Text matching a pattern
`Option(T)`	A value of type `T`, or an omitted or `null` value
`List(R)`	A list of records
A record type	An object containing that record’s inputs

An optional input’s meaning comes from the rating algorithm. It can represent an absent coverage or a value handled by an explicit default.Sections, types and annotations lists every type.

Types and Inputs in the language reference state each form.

Input rules

A where clause restricts an input:

protection_class: Num {precision: int}
    where self in [1, 10] [code: "PROTECTION-CLASS", message: "Protection class must be 1 to 10.", cite: manual:p4]

self refers to the input value. [1, 10] includes both endpoints. The rule carries a code, message, and source citation. A request that breaks this rule receives a refusal with those details.

Example conditions

Rule	Accepted values
`where self in [1, 10]`	From 1 through 10
`where self in (0, 100]`	Above 0, through 100
`where self in [50000, _]`	At least 50,000
`where self in {6, 12}`	Either 6 or 12
`where not self`	`false`
`where len(self) in [1, 6]`	A list containing one through six items

Numeric inputs require a declared precision and range. A set such as {6, 12} further restricts that range.

Rules in the language reference covers rules on lists and records, codes and citations.

Follow-up inputs

A follow-up input is a fact the rater needs only for some risks. The follow-up, question and label excerpts quote this second small rater.

vacancy/rater.rsl

spec {
    rsl: "0.4.1",
    carrier: "Example Mutual",
    state: AZ,
    product: "Dwelling Fire (tour)",
    effective_date: 2026-01-01
}

Sources = {
    manual: Source = {
        artifact: artifact("00000000-0000-4000-8000-000000000000"),
        kind: pdf
    }
}

Types = {
    Money = Num {precision: 0.01}
}

Constants = {
    rate_per_1000 [cite: manual:p3] = 3.25,
    vacancy_load [cite: manual:p5] = 0.02,
    expense_fee [cite: manual:p9] = 35
}

Stages = {
    base: "Base premium" [note: "Coverage A sets the base premium.", cite: manual:p3],
    total: "Policy premium" [note: "A vacancy surcharge and the policy fee complete the premium.", cite: manual:p9]
}

Records = {
    Policy = {
        inputs {
            coverage_a: Money [ask: "What is the Coverage A limit?"] where self in [50000, 2000000],
            vacant: Bool [ask: "Is the dwelling vacant?"],
            vacant_months: Num {precision: int} when self.vacant [ask: "How many months is the dwelling vacant?"]
                where self in [1, 12]
        },
        step base in base [label: "Base premium"] {
            base_premium: BasePremium(Premium) [label: "Base premium", note: "Coverage A in thousands times the base rate.", cite: manual:p3] =
                round(self.coverage_a / 1000 * rate_per_1000, 2, half_up)
        },
        step total in total [label: "Policy premium"] {
            vacancy_factor: Surcharge(Factor) [label: "Vacancy surcharge", note: "Each vacant month adds 2% to the base premium.", cite: manual:p5] =
                if self.vacant then 1 + vacancy_load * self.vacant_months else 1,
            premium: PolicyPremium(Premium) [label: "Policy premium", note: "The surcharged base premium plus the policy fee, rounded to the dollar.", cite: manual:p9] =
                round(self.base_premium * self.vacancy_factor + expense_fee, 0, half_up)
        }
    }
}

RatingOutcomes = {
    premium: Policy.premium
}

when states the condition that makes the input part of a request:

vacant: Bool [ask: "Is the dwelling vacant?"],
vacant_months: Num {precision: int} when self.vacant [ask: "How many months is the dwelling vacant?"]
    where self in [1, 12]

A request for a vacant dwelling supplies vacant_months. A request for an occupied dwelling leaves it out. A calculation reads a follow-up input where its condition holds:

vacancy_factor: Surcharge(Factor) [label: "Vacancy surcharge", note: "Each vacant month adds 2% to the base premium.", cite: manual:p5] =
    if self.vacant then 1 + vacancy_load * self.vacant_months else 1,

Inside if self.vacant then, the compiler knows the answer is present. Ask questions builds a rater with follow-up inputs, and Follow-up inputs in the language reference states the rules.

Questions

An ask annotation gives an input the question a person answers:

coverage_a: Money [ask: "What is the Coverage A limit?"] where self in [50000, 2000000],

The question travels with the rater in its input contract, so an application builds its screens from the rater. The rate stays the same. Other annotations add help text, an answer format and the wording for each choice. Sections, types and annotations lists them, and The input contract shows what an application receives. Questions and choices in the language reference states each annotation’s rule.

Constants and calculations

A constant gives a fixed value a name:

Constants = {
    expense_fee [cite: manual:p9] = 35
}

A step block holds calculations. Each calculation declares its name, type, and formula:

step item {
    charge: Premium [cite: manual:p6] = round(self.value * 0.015, 2, half_up)
}

This calculation charges 1.5% of an item’s value, rounded to cents. self.value reads an input from the same record. RSL keeps arithmetic exact between explicit rounding steps. A calculation is arithmetic over named values, constants, and inputs. The arithmetic can nest, so one step of the filed rating algorithm is one calculation:

premium: Premium [cite: manual:p9] =
    round(sum(Peril as p, self.peril_premium[p]) + self.item_charge + expense_fee, 0, half_up)

In an RSL 0.4.1 rater, a lookup, if, match, round, or pow inside arithmetic gets its own name. The tutorial names its rate lookup base_rate, and peril_premium multiplies by self.base_rate[p]. A label is optional on a working value.

Read and combine calculated values

Expression	Meaning
`self.value`	Read an input or calculation from the same record
`Policy.premium`	Read a named calculation from the policy record
`sum(self.items as i, i.charge)`	Add the charges from a list of items
`sum(Peril as p, self.peril_premium[p])`	Add the premiums across all perils
`if condition then a else b`	Choose between two values

The compiler determines calculation order from dependencies.

Rule clauses

A calculation can end with rule clauses, in this order. A rater that uses them declares rsl: "0.4.1".

Clause	Meaning
`with self.x as x otherwise z`	Use the formula when the optional input `x` has a value. Otherwise, use `z`.
`exception when c then v`	Use `v` when `c` is true. The first true exception applies.
`overridden by self.o`	Use the optional input `o` when it has a value. An override beats each exception.

An exception applies before the formula. with … otherwise decides only whether the formula applies.select(low..high, position) gives a value between a filed low and a filed high. It also needs rsl: "0.4.1".

Preferred forms

To write	Use
A rounded value	Round the arithmetic in the same calculation
A rounded optional input	`round(r, 4, half_up) with self.score as r otherwise 1`
The larger of two values	`max(a, b)`
A signed adjustment, such as a schedule debit 0.10	Multiply by `(1 + adjustment)`
A discount ratio, such as a 5% credit of 0.05	Multiply by `(1 - credit)`
A discount for eligible risks only	A default of 1 and `exception when eligible then factor`
A class or tier from several facts	An `if` or `match` ladder in its own named value
A rule that refuses a request	A `where` rule on the input or record that holds the data

Constants, Steps and calculations and Expressions in the language reference state each form.

Rating tables

The Tables block declares a table’s keys and returned values:

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

The rows live in tables/BaseRate.csv. The column mapping connects each peril’s rate to its CSV column. Read a rate with lookup!:

base_rate[p: Peril]: Rate =
    lookup!(BaseRate, self.dwelling.protection_class).rate[p],

This selects the protection-class band and reads the rate for peril p. Use a filed rate table covers table keys, CSV layouts, and fallback values. Tables and lookups in the language reference states the rules of a table and of lookup!.

Rounding

Each rounding operation states its decimal places and rounding mode:

charge: Premium [cite: manual:p6] = round(self.value * 0.015, 2, half_up)

Here, 2 means two decimal places. half_up rounds halfway values up. Round a premium describes the available rounding modes, and Rounding in the language reference states the rules.

Sources and citations

The Sources block identifies supporting documents:

Sources = {
    manual: Source = {
        artifact: artifact("00000000-0000-4000-8000-000000000000"),
        kind: pdf
    }
}

artifact(...) refers to a document in Effective by its artifact ID. This example uses a placeholder for a synthetic manual. A citation connects a rule or value to a source location:

expense_fee [cite: manual:p9] = 35

manual:p9 means page 9 of the document named manual. Citations explains source locations and citation requirements. Sources and citations in the language reference lists the region form of each source kind.

Labels and concepts

Labels, notes, concepts, and stages describe a rater on its rating manual page. They are optional, and the rate stays the same when a rater adds them. The vacancy rater above declares two stages and labels each filed value:

Stages = {
    base: "Base premium" [note: "Coverage A sets the base premium.", cite: manual:p3],
    total: "Policy premium" [note: "A vacancy surcharge and the policy fee complete the premium.", cite: manual:p9]
}

step base in base [label: "Base premium"] {
    base_premium: BasePremium(Premium) [label: "Base premium", note: "Coverage A in thousands times the base rate.", cite: manual:p3] =
        round(self.coverage_a / 1000 * rate_per_1000, 2, half_up)
},

A label marks a value that the filing names, such as a rating step, a filed factor, a premium, a discount, or a fee. Its note is one sentence.
An unlabelled value is a working value, such as a lookup, a range end, a key, or a partial sum. It takes its role and its citation from the value that it serves. The rating manual shows it inside the value that reads it.
A concept, such as BasePremium(Premium), states what a labelled value is. A concept on a table column, such as BaseRate(Rate[Peril]), applies to each lookup of that column.
Stages names the parts of the filed algorithm, and step base in base puts a step in one part. A step takes its note from its stage or states its own.

An RSL 0.4.1 rater reads the rating@2 vocabulary. Each concept has a role, such as these:

Role	The value is	Example concepts
`premium`	Money in the premium	`BasePremium`, `Subtotal`, `PolicyPremium`, `Fee`
`factor`	A ratio or a signed adjustment in the premium	`Relativity`, `Credit`, `IncreasedLimits`, `Adjustment`
`base`	A starting rate	`BaseRate`
`fact`	A fact about the risk	`Classification`, `Exposure`, `Limit`
`constraint`	A bound, floor, cap, or eligibility test	`Bound`, `MinimumPremium`, `Eligibility`
`choice`	An underwriter selection or override	`Selection`, `Override`

A Credit is a discount ratio, such as 0.05, that applies as 1 - credit. A filed multiplier, such as 0.80, is a Relativity.
A fact that the request supplies is a Classification or another fact.
For a value that lacks a concept, the compiler infers the role from the values that read it.

On the rater page, each labelled premium, factor, or base value is one row of the calculation. A labelled bound shows inside the value that it bounds. Each step lists its checks. Variables lists the inputs, lookups, and outcomes, and Tables lists the rate tables. The rating manual messages explain the checks on labels, concepts, and calculation forms. Stages, labels, notes and concepts in the language reference lists each form and concept.

Rating outcomes

RatingOutcomes selects the values returned by the rater:

RatingOutcomes = {
    premium: Policy.premium
}

This publishes the policy’s calculated premium under the outcome name premium. Outcomes in the language reference lists the types an outcome may have.

Guidelines

A guideline is a second RSL file that holds underwriting rules. It uses a rater and adds roles, question owners and referrals. These excerpts quote the staffing example on the examples page. use links the rater under a name, and Roles orders the people who answer and sign off:

use ts = "rater.rsl"

Roles = { assistant < uw < manager }

An input names the role that answers it with by, and a calculation reads the rater’s premium:

financially_sound: Bool by @Role.uw when self.operation = @Operation.peo [cite: guideline:p1],
policy: ts.Policy,
policy.experience by @Role.uw

premium: Premium = ts(self.policy).premium

A refer clause sends a submission to a role for sign-off:

refer new_venture when self.years_in_operation < established_years
    to @Role.manager because "The firm is in operation for less than 3 years." [cite: guideline:p1]

A referral holds the quote until a manager signs it off. A where rule on the record still refuses a submission outright. Write your first guideline builds this example, and Raters and guidelines explains the split. Guidelines in the language reference states each form.

Next steps

Write your first rater to run the complete example.
Read Checks and guarantees to understand what the compiler verifies.
Use the rslc commands to check and package a rater.
Look up a form in the language reference.

Get started

Tutorials

Implement a filing

Test a rater

Quote and underwrite

Concepts

Reference

File structure

Types and inputs

Input rules

Follow-up inputs

Questions

Constants and calculations

Rating tables

Rounding

Sources and citations

Labels and concepts

Rating outcomes

Guidelines

Next steps

​File structure

​Types and inputs

​Input rules

​Follow-up inputs

​Questions

​Constants and calculations

​Rating tables

​Rounding

​Sources and citations

​Labels and concepts

​Rating outcomes

​Guidelines

​Next steps

File structure

Types and inputs

Input rules

Follow-up inputs

Questions

Constants and calculations

Rating tables

Rounding

Sources and citations

Labels and concepts

Rating outcomes

Guidelines

Next steps