> - There's already a lot of moving parts to type hinting, so adding
> this optional approach into defn seems like it'd lead to unintended
> consequences. That said, there's absolutely nothing wrong with an
> alternative def form (defh? as in 'define hinted fn') -- there's
> plenty of them throughout contrib and elsewhere.
Yeah, I tried to slip my change into a place in defn that probably
wouldn't hurt anything, but I'm still not sure what the full
consequences of my change are. I'm far from a clojure expert :)
> - Remember destructuring, and along with that, one of the nice thing
> about in-place hints, as opposed to a separate definition of expected
> types, is that the definitions can be sparse, e.g.:
>
> (defn foo [{blah :foo #^MyType mt-obj :bar} a b c] ...)
>
> It doesn't look like your macro supports hinting destructured args
> (understandably enough, doing so given the :signatures approach would
> likely be very difficult).
I didn't put it in yet, but I was thinking of just having nil in the
type vector for unhinted variables, so you could have
(defn foo {:signature [ String String nil ]} [ a b c ] ...)
and then c wouldn't be hinted. I hadn't thought of destructuring at
all; I'm guessing that it could be done with
(defn foo {:signature [{:bar Mytype} nil nil nil]} [{blah :foo mt-obj
:bar} a b c] ...)
but that's getting pretty ugly on its own. I'm not sure if it would
be a win to try to do anything fancy like that. I'm also not sure
what the destructuring assignment syntax is for maps right now, so
what I wrote might be total nonsense, syntactically. I hope the idea
is clear, anyhow.
> - The thing I don't like about the current type hints is (IMO) the
> distracting quality of '#^'. What about something like:
>
> (defh foo [String:s unhinted-arg {int:a :a}] ...) or
> (defh foo [s:String unhinted-arg {a:int :a}] ...)
>
> That's far more visually-appealing to me, and has the nice advantages
> of being inline in the case of destructuring and supporting sparse
> hinting easily. I'll bet the macro would end up being pretty simple,
> as well.
I'd hate to see somebody do it, but it's currently valid to define
variables with colons in them, so there could be code out in the wild
with those definition forms already. Other than that, I like the
looks of it. I think the macro would be easy as well, so long as
you're comfortable munging variable names :)
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
-~----------~----~----~----~------~----~------~--~---
