Redo struct signatures

[mikesperber]

This is from a discussion Matthias Felleisen and I had at ICFP 2019:

The previous version of the signature support had as the name of the
signature the name of the struct, which made for confusing error
messages.

Now, camelcase the struct name: dillo -> Dillo, foo-bar -> FooBar.

This is in line with HtDP's conventions, I think. Also, primitive
signatures start with an upper-case letter.

The signature constructors append an "Of": DilloOf, FooBarOf etc.

[mikesperber]

Here's some code that uses it:

; Ordinary structs
(define-struct dillo (alive? weight))

(: make-dillo (Boolean Integer -> Dillo))
(: dillo? (Any -> Boolean))
(: dillo-alive? (Dillo -> Boolean))
(: dillo-weight (Dillo -> Integer))

(: run-over-dillo (Dillo -> Dillo))

; almost works, but doesn't because:
; - no parametric signatures for mutable structs
; - all structs are mutable in Advanced student
#;(check-property
 (for-all ((dillo (DilloOf Boolean Integer)))
   (not (dillo-alive? (run-over-dillo dillo)))))

; Note we can't just write Dillo instead of (DilloOf ...) as the
; signatures of the fields aren't specified.

(define (run-over-dillo dillo)
  (make-dillo #false
              (dillo-weight dillo)))


; Lists

(define-struct empty-list ())

(define nil (make-empty-list))

(define-struct pair (car cdr))

(: make-pair (%a (ListOf %a) -> (PairOf %a (ListOf %a))))
(: pair-car ((PairOf %a (ListOf %a)) -> %a))
(: pair-cdr ((PairOf %a (ListOf %a)) -> (ListOf %a)))

(define (ListOf a)
  (signature
   (mixed EmptyList
          (PairOf a (ListOf a)))))

(define lis1
  (make-pair 5 (make-pair 7 (make-pair 3 nil))))

(: list-sum ((ListOf Number) -> Number))

(check-expect (list-sum lis1) 15)

(define (list-sum lis)
  (cond
    ((empty-list? lis) 0)
    ((pair? lis)
     (+ (pair-car lis)
        (list-sum (pair-cdr lis))))))

#|
I would really like:

- signatures in *BSL, not just ASL

- inline struct signatures:

(define-struct dillo
   ([alive? Boolean]
    [weight Integer]))

   Then we could also do:

(check-property
 (for-all ((dillo Dillo))
   (not (dillo-alive? (run-over-dillo dillo)))))
 
- combine that with parametric signatures

(define-struct (pair a)
  ([car a]
   [cdr (ListOf a)]))

  We could then replace (PairOf x (ListOf x)) by (PairOf x)

|#

[mikesperber]

Tests and documentation forthcoming, once there is agreement on the design.

[mfelleisen]

I don’t quite understand this part:

"I would really like:

• signatures in *BSL, not just ASL

• inline struct signatures:”

The first one is something you can re-enable. It used to work, right?

The second one would mean a major change to the syntax of structs, even if we make these field specs optional. Students could stumble into this notation and get rather confusing error messages.

[mikesperber]

@mfelleisen I believe it's always been the case that they were only available in ASL, at your request. But indeed, they would be easy to turn on in all the *SL.

As to inline struct signatures: I agree with your assessment. We introduced this in SdP, but that has new language levels and a new keyword. Maybe that's the way to do it?

[mfelleisen]

(I thought I had turned them off.) Let’s turn them on for 7.7.

[samth]

What's the status here?

[mfelleisen]

No news …

[mikesperber]

@samth Adding tests for that is next on my list, then it should be ready to merge.

[mikesperber]

Tests are there now.

[mikesperber]

Documentation is there.

@samth @mfelleisen Could you take a look and let me know what's missing?