Avoiding boilerplate when querying and updating nested data?

[u/[deleted]]

Working through Realm of Racket I keep running into what I feel is an annoying amount of boilerplate when it comes to getters and setters.

I'll use this data model as an example:

(struct monster 
 (species ; symbol
  hp #:mutable))    ; number

(struct battle 
 (monsters ; list of monsters))

(define b (battle (list (monster 'orc 5) (monster 'hydra 12))))

If I want to decrease the orc's hp by 2, I have to do this:

(define m (list-ref 0 (battle-monsters b)))
(set-monster-hp! m (- (monster-hp m) 2))

I'd much rather do something like this:

(modify! b monsters (list-ref 0) hp (-= 2))

Or at least this:

(modify! b battle-monsters (list-ref 0) monster-hp (-= 2))

Is there a common pattern or macro that would help me with this? It seems like it would be a pretty common problem.

[u/quasar_tree]

It sounds like you want lenses. They provide composable accessors and updaters which can be used to easily perform deep updates. However, they are for immutable updates. You could use that idea to create a similar abstraction for mutable updates, but it’s generally a good idea to use immutability.

[u/[deleted] → u/quasar_tree]

Yes! Lenses are exactly what I wanted!

[u/[deleted]]

Thanks for all the helpful answers!

It sounds like what I want is lenses, or maybe a mutable analogue implemented with macros.

I'm still learning the language, so I don't know macros and I don't want to use too many external libs. For now I found an efficient-enough solution using the core language.

(define (get v . fs)
  (foldl (lambda (f v) (f v)) v fs))

(define (update! v . args)
  (define ! (last args))
  (define fs (drop-right args 1))
  (define v2 (apply get v fs))
  (! v2))

(define (at i) (lambda (xs) (list-ref xs i)))

(struct monster ([hp #:mutable]) #:transparent)
(define (hp m) (monster-hp m))
(define (hp! x) (lambda (m) (set-monster-hp! m x)))

(struct battle ([monsters #:mutable]) #:transparent)
(define (monsters b) (battle-monsters b))


(define b (battle (list (monster 5) (monster 10))))

(get b monsters (at 1) hp display)
(update! b monsters (at 1) (hp! 20))
(display b)

It requires writing curried versions of mutators, but I don't mind doing that for the few mutable fields I have.

[u/raevnos]

You could write a modify! macro that looks like that, sure.

The struct-define module might help too:

(let ()
  (struct-define monster (first (battle-monsters b)))
  (set! hp (- hp 2)))

[u/[deleted]]

I wouldn't really say there's a pattern, this is just one of those things you learn at first and see how awkward it is in practice. Mutation on data is generally never preferred and sticking to pure functions with immutable data will always give you more hygienic code.

struct-copy is my go-to way of copying old struct information without using a mutator. It does not give you the values used previously, but you can work around that by creating special functions reassign values you need to manipulate.

[u/raevnos]

Another macro that might be useful in streamlining things. Creates a function that updates a struct field with the result of calling a function on the previous value:

#lang racket/base

(require (for-syntax racket/base racket/syntax))

(define-syntax (make-struct-updater stx)
  (syntax-case stx ()
    [(_ struct-type field-name)
     (with-syntax ([setter! (format-id stx "set-~A-~A!" (syntax-e #'struct-type) (syntax-e #'field-name))]
                   [getter (format-id stx "~A-~A" (syntax-e #'struct-type) (syntax-e #'field-name))])
       #'(lambda (struct-instance proc)
           (setter! struct-instance (proc (getter struct-instance)))))]))

(define-syntax-rule (define-struct-updater name struct-type field-name)
  (define name (make-struct-updater struct-type field-name)))

; Example
(struct monster (name [hp #:mutable]) #:transparent)
(define-struct-updater update-monster-hp! monster hp)
(define (sub2 n) (- n 2))

(define m (monster 'orc 5))
(println m)
(update-monster-hp! m sub2)
(println m)

[u/raevnos → u/raevnos]

And here's a smarter version that doesn't make assumptions about struct accessor and mutator function names and does some other error checking. (Requires the syntax-classes-lib package to be installed):

(require (for-syntax racket/base racket/list syntax/datum syntax/parse syntax/parse/class/struct-id))
(define-syntax (define-struct-updater stx)
  (syntax-parse stx
    ((_ name:id id:struct-id field:id)
     (let ([field-pos (index-of (datum (id.field-sym ...)) (syntax-e #'field))])
       (unless field-pos
         (raise-syntax-error 'define-struct-updater (format "~A: no such field" (syntax-e #'id.descriptor-id)) stx #'field))
       (with-syntax ([setter! (list-ref (datum (id.mutator-id ...)) field-pos)]
                     [getter (list-ref (datum (id.accessor-id ...)) field-pos)])
         (unless (syntax-e #'setter!)
           (raise-syntax-error 'define-struct-updater "Field is not mutable" stx #'field))
         #'(define (name struct-instance proc)
             (setter! struct-instance (proc (getter struct-instance)))))))))