> * If we have users write types in interfaces, what happens when
> untyped classes try to implement those interfaces?
Untyped interfaces can specify contracts for their methods, so could it use
that?
> * What do interface types look like? Do they list the types of methods
> that should be in them?
Based on the interface form and the Class type constructor (in v6.0.1.6), I
think that they should look something like this:
(Interface interface-type-clause ...)
interface-type-clause = [method-id method-type]
| #:implements interface-type
This is basically a simplification of the grammar for the Class type
constructor, and it matches the grammar of the interface form even better than
the new Class type constructor matches the grammar for the class form.
And it would mean that a class that uses the interface would implement the
methods given, with the types given, and would also implement the interfaces
given by #:implements.
So the type of this:
(require/typed “untyped.rkt” [foo<%> Foo<%>]
(class* object% (foo<%>)
...
)
would have a type that includes #:implements Foo<%>, and if Foo<%> is
(Interface #:implements Super-Interface<%> [m t]), then that would mean that it
would include #:implements Super-Interface<%> and [m t]. The things in the
Interface type could go right into the Class type.
So this:
(Class stuff ... [m1 t1] ... #:implements (Interface [m2 t2] ... #:implements
(Interface [m3 t3] ...)))
Would mean the same as this:
(Class stuff ... [m1 t1] ... #:implements (Interface [m2 t2] ... [m3 t3] ...))
Which would mean the same as this:
(Class stuff ... [m1 t1] ... [m2 t2] ... [m3 t3] ...)
By the way I also noticed that class* doesn’t seem to work in typed racket
either.
> Do you have a use case in mind for interface types?
Not really anymore.
I was trying to make my own types for some of the things in racket/gui, but the
new version has that already (in typed/racket/gui).
By the way it seems like typed/racket/gui is treating interface types like
class types anyway, and since #:implements can be used more than once, it seems
like it’s expecting that interface types should be represented with class
types.
But still, what if I wanted to do something like this:
(class* object% (printable<%>)
(super-new) (inspect #f)
(: custom-print (Output-Port (U 0 1) -> Void))
(define/public (custom-print out d)
...)
(: custom-write (Output-Port -> Void))
(define/public (custom-write out)
...)
(: custom-display (Output-Port -> Void))
(define/public (custom-display out)
...))
But that’s still a what if case.
> We've thought about adding something like #:implements/inits or
> something like that for this use-case, but we haven't implemented
> anything yet. Does that sound like it would be useful to you?
Yes, it does sound useful.
I made a class called frame-with-callback% that inherits everything from frame%
but adds callback init arguments and overrides the on-subwindow-char and
on-subwindow-event methods. I can just rewrite all of the init arguments from
frame%, but it would be nice to have something like #:implements/inits.
____________________
Racket Users list:
http://lists.racket-lang.org/users
