Welcome to this week's edition of "Confusing myself with Typed Racket".*
I want to import `response/xexpr-wrap` -- a version of `response/xexpr`
that does some additional styling -- in a typed/racket file. So thanks to
Ben and Jon in another thread, I now do
```
(require/typed xml [#:opaque Xexpr xexpr?])
(require/typed "tools.rkt" [#:opaque Response response?]
[response/xexpr-wrap (-> Xexpr Response)])
(define x '(body (h1 "Not so Hello world")))
(response/xexpr-wrap x)
```
And this does not work. I get the error
```
expected: Xexpr
given: (List 'body (List 'h1 String))
```
even though it passes the `(xexpr? x)` passes, returning #t. I was somewhat
surprised by this, but I guess the issue is that opaque types can only work
at runtime on code from non-typed modules. However, since I pass `x` as an
argument in my file, the type checker wants to type check it now, rather
than putting contracts around the arguments passed into
`response/xexpr-wrap`.
If this is the case, is it possible to use opaque types to type check
arguments into functions required from non-typed modules? Well, I can
probably hack my way around this: I write a non-typed function in
`tools.rkt` called `this-is-an-xexpr` which I require/typed with `(-> Any
Xexpr)`, which if I understand things correctly should put run-time
contracts around that function, but type check. (See below, I went and
checked whether this worked, and it does.) A less hacky way would be to be
less lazy and define an Xexpr type via `define-type Xexpr (U String Symbol
(Listof ...)...)` and so on. This is probably what I'll do, but I wanted to
know what is going on anyway.
If it is not the case, what is going on that makes this not work?
Despite having found a way to make this work, I'd like to know if there is
a non-hacky way, whether I understand correctly why my naive approach
failed, and what the (or a) recommended way of doing this is.
Cheers - until next time.
Marc
EDIT LATER: Hah, my hack works!
```{tools.rkt}
#lang racket
(provide make-xexpr ...)
(define (make-xexpr xexpr)
xexpr)
```
and then in my typed file:
```
#lang typed/racket
(require/typed "tools.rkt"
[#:opaque Response response?]
[#:opaque Xexpr xexpr?]
[make-xexpr (-> Any Xexpr)]
[response/wrap-xexpr (-> Xexpr Response)])
(define x '(body (h1 "Not so Hello world")))
(response/wrap-xexpr (make-xexpr x))
```
and this works. Nice, in an ugly kind of way.
*: Despite said confusion, ever since I got past the initial hump of using
Typed Racket, it's been really useful though as it catches a substantial
fraction of my bugs that would require sprinkling lots of printfairy dust
to find and fix.
--
You received this message because you are subscribed to the Google Groups
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit
https://groups.google.com/d/msgid/racket-users/0e428a87-095a-48fc-a31a-b393f4672642%40googlegroups.com.
