Question

假设我有一个包含许多字段的结构：

(struct my-struct (f1 f2 f3 f4))

如果我要更新f2更新的新结构，我必须改写其他所有字段：

(define s (my-struct 1 2 3 4))
(my-struct (my-struct-f1 s)
           (do-something-on (my-struct-f2 s))
           (my-struct-f3 s)
           (my-struct-f4 s))

如果我更新字段数量或更改订单，那么这将是多余的错误来源。

我真的很想知道是否有这样的方法可以更新结构的特定字段：

(my-struct-f2-update (my-struct 1 2 3 4)
                     (lambda (f2) (* f2 2)))
;; => (my-struct 1 4 3 4)

或者我可以将它们设置为新值：

(define s (my-struct 1 2 3 4)
(my-struct-f2-set s (* (my-struct-f2 s) 2))
;; => (my-struct 1 4 3 4)

注意，这不是在变异s; my-struct-f2-update和my-struct-f2-set应该只返回s的副本，并更新f2字段。

在Haskell，我知道完成这项工作的'镜头'库。我只是想知道是否有一些类似的方式我可以采用球拍。感谢。

Answer 1

你知道吗？这是非常好的主意。事实上，在某些情况下，我想要这个功能，但我没有。坏消息是Racket提供的不是这类。好消息是，Racket有宏！

我向你展示define-struct-updaters！

(require (for-syntax racket/list
                     racket/struct-info
                     racket/syntax
                     syntax/parse))

(define-syntax (define-struct-updaters stx)
  (syntax-parse stx
    [(_ name:id)
     ; this gets compile-time information about the struct
     (define struct-info (extract-struct-info (syntax-local-value #'name)))
     ; we can use it to get the constructor, predicate, and accessor functions
     (define/with-syntax make-name (second struct-info))
     (define/with-syntax name? (third struct-info))
     (define accessors (reverse (fourth struct-info)))
     (define/with-syntax (name-field ...) accessors)
     ; we need to generate setter and updater identifiers from the accessors
     ; we also need to figure out where to actually put the new value in the argument list
     (define/with-syntax ([name-field-set name-field-update
                           (name-field-pre ...) (name-field-post ...)]
                          ...)
       (for/list ([accessor (in-list accessors)]
                  [index (in-naturals)])
         (define setter (format-id stx "~a-set" accessor #:source stx))
         (define updater (format-id stx "~a-update" accessor #:source stx))
         (define-values (pre current+post) (split-at accessors index))
         (list setter updater pre (rest current+post))))
     ; now we just need to generate the actual function code
     #'(begin
         (define/contract (name-field-set instance value)
           (-> name? any/c name?)
           (make-name (name-field-pre instance) ...
                      value
                      (name-field-post instance) ...))
         ...
         (define/contract (name-field-update instance updater)
           (-> name? (-> any/c any/c) name?)
           (make-name (name-field-pre instance) ...
                      (updater (name-field instance))
                      (name-field-post instance) ...))
         ...)]))

如果您不熟悉宏，它可能看起来有点吓人，但它实际上并不是一个复杂的宏。幸运的是，您不需要了解它如何使用它。以下是您的表现方式：

(struct point (x y) #:transparent)
(define-struct-updaters point)

现在，您可以随心所欲地使用所有相关的功能设置器和更新器。

> (point-x-set (point 1 2) 5)
(point 5 2)
> (point-y-update (point 1 2) add1)
(point 1 3)

我相信有一些理论计划要重新设计Racket结构系统，我认为这将是一个有价值的补充。在此之前，请随意使用此解决方案。我已将此答案中的代码设为the struct-update package，可以使用raco pkg install struct-update进行安装。

Answer 2

我喜欢亚历克西斯的宏观！它有更多你想要的“镜头”味道。

我还想指出struct-copy。给出：

#lang racket
(struct my-struct (f1 f2 f3 f4) #:transparent)
(define s (my-struct 1 2 3 4))

您可以使用struct-copy设置值：

(struct-copy my-struct s [f2 200])
;;=> (my-struct 1 200 3 4)

或更新值：

(struct-copy my-struct s [f2 (* 100 (my-struct-f2 s))])
;;=> (my-struct 1 200 3 4)

更新：再考虑一下这里有更多想法。

您还可以使用match的{{1}}模式进行更新：

struct*

当然，这非常冗长。另一方面(match s [(struct* my-struct ([f2 f2])) (struct-copy my-struct s [f2 (* 100 f2)])]) 使用更简单的模式可以轻松定义宏 struct*：

define-syntax-rule

当然，设置是您提供更新的特殊情况 ;; Given a structure type and an instance of it, a field-id, and a ;; function, return a new structure instance where the field is the ;; value of applying the function to the original value. (define-syntax-rule (struct-update struct-type st field-id fn) (match st [(struct* struct-type ([field-id v])) (struct-copy struct-type st [field-id (fn v)])])) (struct-update my-struct s f2 (curry * 100)) ;;=> (my-struct 1 200 3 4)功能：

const

最后，这就像(struct-update my-struct s f2 (const 42)) ;;=> (my-struct 1 42 3 4)，但是返回一个更新程序功能，本着Alexis宏的精神：

struct-update

我并不是说这些都是惯用的或有效的。但这是可能的。：）

Answer 3

亚历克西斯的宏太棒了，格雷格正确地指出了struct-copy和match+struct*，但由于你在你的例子中特别提到镜头，我会指出there is now a lens package for Racket（免责声明：我写的很多）。它为您的用例提供了struct/lens和define-struct-lenses个宏：

> (struct/lens foo (a b c))
> (lens-view foo-a-lens (foo 1 2 3))
1
> (lens-set foo-a-lens (foo 1 2 3) 'a)
(foo 'a 2 3)
> (lens-transform foo-a-lens (foo 1 2 3) number->string)
(foo "1" 2 3)

define-struct-lenses让你可以从结构中单独定义镜片：

> (struct foo (a b c))
> (define-struct-lenses foo)

以上相当于(struct/lens foo (a b c))。如果您只是在与其他类型的结构隔离的结构上运行，则使用define-struct-updaters会更简单。但是如果你有很多不同风格的嵌套数据结构，那么组合镜头的能力使它们成为这项工作的有力工具。

是否有一种速记方式来更新球拍中的特定结构字段？

3 个答案: