Casilian StudiosCASILIANMODDING SCHOOL

WillowScript (.ws) is a proposed, not-yet-implemented language. Examples and library integrations here are illustrative design exercises, not verified runnable programs.

WillowScript Fast Track · Keep unrelated rules in separate groups

Organize related declarations with domain — Build the smallest useful slice

Contrast native Willow with WillowScript: Organize related declarations with domain: build the smallest useful slice.

Practice saves only on this browser.

PART I

Warm-up

Reconnect with a useful idea before starting organize related declarations with domain. In one or two sentences, describe the input, output or host boundary from the previous exercise that this lesson builds on. If you are arriving directly, skim the worked example first; there is no locked prerequisite.

A rough note is enough. You can revise it after the example.

PART II

Instruction & guided example

Keep unrelated rules in separate groups

A domain groups related declarations in the shown language design. For an experienced Willow learner, use it to make responsibility boundaries readable, while avoiding assumptions about instance creation, automatic public exposure or how an external caller qualifies a name. Exact module/export behavior still needs its documented contract.

A workshop needs pricing arithmetic and remaining-stock arithmetic. The sample responsibility table assigns price+fee to Pricing and capacity-used to Inventory. For price 90/fee 10, Pricing predicts 100 cents; for capacity 12/used 4, Inventory predicts 8 parts. Separation keeps different units and review assumptions from blending into one vague Utility group.

Splitting groups does not itself enforce security isolation. A readable boundary is helpful, but actual exposed APIs and capability checks remain host policy. Do not claim that Inventory cannot be reached merely because it is in a different domain.

Worked reasoning and supplied artifact

// Worked contract artifact:
// A workshop needs pricing arithmetic and remaining-stock arithmetic. The sample responsibility table assigns price+fee to Pricing and capacity-used to Inventory. For price 90/fee 10, Pricing predicts 100 cents; for capacity 12/used 4, Inventory predicts 8 parts. Separation keeps different units and review assumptions from blending into one vague Utility group.

Illustrative example from the proposed WillowScript design. The language and WUIX/WMATH/WDB/WAUDIO/WTMP services are not implemented in the supplied source. This site has no interpreter, VM or native host and does not execute or certify the snippet.

Walk through the example, one line at a time
  1. // Worked contract artifact:

    This comment explains intent for a reader. It is not an operation and should not be counted as an executed result.

  2. // A workshop needs pricing arithmetic and remaining-stock arithmetic. The sample responsibility table assigns price+fee to Pricing and capacity-used to Inventory. For price 90/fee 10, Pricing predicts 100 cents; for capacity 12/used 4, Inventory predicts 8 parts. Separation keeps different units and review assumptions from blending into one vague Utility group.

    This comment explains intent for a reader. It is not an operation and should not be counted as an executed result.

Try the guided change

Make the responsibility/unit table and trace one calculation from each group.

  • Write the supplied inputs and initial state before following the example.
  • Reconstruct each intermediate calculation or host decision, then compare with the worked artifact.
  • Explain why the contrasting alternative fails before attempting the changed inputs in Part IV.

PART III

Take a breather

Step back after the guided example. Look away from the screen, stretch, or reread your prediction. This is an optional learning pause, not a timer or an assessment gate.

When you return, try to name the lesson’s key idea without copying its wording. If that feels difficult, return to Part II and trace one line rather than restarting the entire lesson.

Your drafts remain here. Continue whenever you are ready.

PART IV

Independent practice

Project context: Shared pricing rules. Build a small, understandable change around organize related declarations with domain.

Design two declaration groups for a mod workshop: reward points and remaining material count. Give each one focused helper and a paper case, then state the difference between grouping and access control.

What to produce

Two domain drafts, distinct unit contracts and a separate exposure-policy note.

  • State the intended behavior in a sentence before editing.
  • Use only source-backed syntax and the host services whose contract you have been given.
  • Record a normal case and a boundary or unavailable-resource case.
  • Label hand predictions separately from anything actually measured in a supplied toolchain.

Syntax colors are a reading aid, not a compiler. The line you are editing stays uncolored until you move to a different line; capitalization is never changed. Drafts stay on this browser and code is not executed.

Need a hint?

A workshop needs pricing arithmetic and remaining-stock arithmetic. The sample responsibility table assigns price+fee to Pricing and capacity-used to Inventory. For price 90/fee 10, Pricing predicts 100 cents; for capacity 12/used 4, Inventory predicts 8 parts. Separation keeps different units and review assumptions from blending into one vague Utility group.

Splitting groups does not itself enforce security isolation. A readable boundary is helpful, but actual exposed APIs and capability checks remain host policy. Do not claim that Inventory cannot be reached merely because it is in a different domain.

Original learning-path task and reference

Use your Willow knowledge to implement the .ws host integration, explaining which work remains native and which belongs in the script. In a small-shop operations tool, demonstrate organize related declarations with domain. Create the smallest .ws integration that demonstrates the section contract. Include .ws source and a host-resource contract; compare at least one normal case and one edge case.

fnc add(a: i32, b: i32) -> i32 {
    return a + b;
}
fnc main() -> i32 {
    return add(2, 3);
}

Where the original task needs a host API that is not supplied here, write the contract and predictions. Do not invent a runtime result.

PART V

Self-check

Use this check to notice what to revisit. It does not award a private course grade, block another page or claim to verify compiled code. Every answer has a learning explanation.

Does splitting domains automatically establish a permission barrier?

You may keep exploring even if you are unsure. Use the hint, compare the trace, and revise your explanation.

PART VI

Recap & small task

Bring the idea back to the mod feature you are building. A useful recap connects the mechanism to a decision you can make in your own code.

  • Keep unrelated rules in separate groups
  • Make the responsibility/unit table and trace one calculation from each group.
  • Separate source-backed behavior, host requirements and untested predictions.

One small recap task

Make the responsibility/unit table and trace one calculation from each group.

This marks your personal practice record only. It is not a certification or an official workspace assessment.

Your practice, on this browser

No public account is created. Drafts and lesson progress stay in this browser’s local storage. They do not automatically follow you to another device and can be lost if browser storage is cleared.

Export a private progress file to keep a copy, then import it on another browser when you want to move your work. Treat that file as your own writing; it can contain your practice drafts.