Struct updater syntax

[macrologist]

Coalton should support syntax for updating fields of structs to return new, updated, structs.

E.g.

(define-struct Pt 
   (x Integer)
   (y Integer))

;; we can get get filelds 

(declare manhattan-magnitude (Pt -> Integer))
(define (manhattan-magnitude point)
    (+ (.x point) (.y point)))

(let ((p (Pt 10 20)))
   (manhattan-magnitude p))   ;; => 30

But it would be nice if Coalton supported a standard syntax for updating structures to return a new structure.

This hypothetical syntax might look like this:

;; ... continuing from above ...

(let ((p (Pt 10 20)))
    (!x 30 p))            ;; => (Pt 30 20)

My personal preference would be for (!x 30) in the above to return a function of type Pt -> Pt so that common update and folding patterns could be supported:

(declare translate (Integer -> Integer -> Pt -> Pt)
(define (translate dx dy p)
  (let (Pt x y) = p)
  (.>  p
        (!x (+ x dx))
        (!y (+ y dy)))
      
(translate 10 10 (Pt 20 30))   ;; => (Pt 30 40)

Such a change would dramatically reduce boilerplate when updating large structures.

The syntax itself isn't very important, anything that is agreeable to users would be cool.

Are there any obvious ick-factors here?

[stylewarning]

The only thing I can think is to allow parallel setting so we can produce more efficient code.

[macrologist]

Something like:

(struct-update .x (+ x dx) .y (+ y dy))  ;; Pt -> Pt 

But with an infinitely nicer and therefore hard to think of keyword

[macrologist]

(let p = (Pt 0 0))
(Pt= (.x 10) p)) ;; (Pt 10 0)
(Pt= (.y 20) p)) ;; (Pt 0 20)
(Pt= (.y 20) (.x 10) p) ;; (Pt 10 20)

[fukamachi]

In my experience with immutable data in React,
it usually works nicely when updating a direct field, but it tends to be verbose when trying to update nested fields.

;; To update (.city (.address person))
(match person
  ((Person name address age)
   (.> person
       (!name "Alice")
       (!address (.> address
                     (!city "Portland")
                     (!zip "97201"))))))

[macrologist]

@fukamachi @stylewarning are we moving toward lenses ?

[stylewarning]

[garlic0x1]

Here is an idea for something that would work on union types even with anonymous fields:

COALTON-USER> (coalton-toplevel 
                (define-type Point 
                  (Point2 Integer Integer)
                  (Point3 Integer Integer Integer)))
; No values
COALTON-USER> (coalton-toplevel
                (define (shift-right pnt) 
                  (update pnt 
                    (Point2 1+ _)
                    (Point3 1+ _ _)))
                
                (define (zero-z pnt)
                  (swap pnt 
                    (Point2 _ _)
                    (Point3 _ _ 0))))

update and swap have match-like syntax, update applies functions to slots and swap puts new values in the slots.
_ patterns keep the original value in both cases.

[garlic0x1]

This might also be nice with nesting because we can just reach in with patterns.

[garlic0x1]

#1673
Here is a demo of the idea