Array methods in FSCSS (.reverse, .list, .length, and the rest) have been around since v1.1.14. They return strings, not array objects, and chaining is not supported. So for a long time the practical question was: how do you take a method result and keep working with it as a collection?

Derived arrays (v1.2.3+) are the answer. You declare a new @arr whose body is another array’s method output. The compiler resolves that into a proper array you can index, loop, and derive from again.

Docs: fscss.devtem.org/arrays

Core idea

@arr colors[#1E2783, #8C29B2, #C41348] @arr reversed[@arr.colors!.reverse] @arr asList[@arr.colors!.list] @arr idx[count(@arr.colors!.length, 1)] 
  • @arr.reversed — reversed values as an array
  • @arr.asList — comma-separated list (string-shaped, but held in an @arr declaration when you need that form)
  • @arr.idx — 1-based index sequence sized to the source length

Methods still need the ! method-access form. Derivation is how you avoid pretending those results are chainable objects.

Mutation using another array’s list

@arr more[#0ea5e9] @arr.colors!+[@arr.more!.list] /* append items from more */ 

.list turns the second array into a form the mutation operator can consume. Same family of ideas: method → string-ish payload → use it in a declaration or mutation, don’t chain.

Practical pattern: index + reverse (charts, dual-pass polygons)

Modules like st-core@v2 use this for strokes that walk a path forward, then back:

@arr data[40, 60, 20, 80, 50] @arr data-idx[count(@arr.data!.length, 1)] /* 1, 2, 3, 4, 5 */ @arr data-reversed-idx[@arr.data-idx!.reverse] /* 5, 4, 3, 2, 1 */ 

Loop the index arrays, read original values or --varN by index, build clip-path / polygon points in one pass for the top edge and another for the return edge. Derivation keeps “length → indices → reversed indices” explicit and stable under 1.2.3+ resolution rules.

count() can take a length expression (including @arr.name!.length) so index arrays stay tied to the data array instead of a hard-coded 5.

Limitations (still real)

Constraint What to do instead
No method chaining Derive @arr step1[...], then method on step1
Methods return strings New @arr when you need array semantics again
Runtime vs ship Prefer CLI for production static CSS; runtime 1.2.3+ is fine for prototyping

Invalid:

/* don't */ @arr.x!.unit(px)!.join(+) 

Valid shape:

@arr withUnit[@arr.x!.unit(px)] /* then use withUnit or a method on withUnit */ 

Methods that pair well with derivation

Method Typical derivation use
.reverse Dual-pass polygons, reverse visual order
.list Feed mutations / comma-separated payloads
.indices Explicit 1-based index lists
.length Argument to count() for parallel index arrays
.unique Deduped collections
.sort Ordered variants
.unit(val) Attach units for spacing/size scales
.prefix(v) Class or token name stems

Mental model

  1. Store data in @arr name[...]
  2. Inspect / transform with @arr.name!.method
  3. Capture the result in @arr next[@arr.name!.method] when you need another array
  4. Loop with @arr.next[] or index into @arr.data[@arr.idx[]]

That four-step loop is how FSCSS stays expressive without pretending methods return rich objects.

Derived arrays don’t add a new runtime type. They make an existing rule reliable: methods yield strings; new @arr declarations turn the ones you care about back into collections. Since 1.2.3, that resolution path is solid enough for real module patterns—index arrays, reversed passes, list-based appends—without hand-duplicating values.

When a transform is only used once, a method in place may be enough. When you need to loop or index the result, derive.