It is possible to check and compare the types of parameters?

[Andre-LA]

Hello, I'm trying to check if a value x and y are from the same type when called, so I can do something different if they're equal or different.

I tried Dynamic.type, but it didn't worked for me (the compiler either runs forever (I'm using the latest release) or it errors with Can't find symbol `x` ).

So, it is currently possible?

(defn same-types [x y]
	(= (typeof x) (typeof y)))

(defn main []
	(let [x 10 y 20]
		(if (same-types x y)
			(IO.println "both x and y are from the same types!")
			(IO.println "both x and y are from the different types!"))))

[scolsen]

It's been a while since I've spent time on Carp stuff, so I'll need to look into this again when I do so, but in the meantime here's some info that might help:

1. If you're using the static part of carp defn you shouldn't need a function like this. Carp's type system will should handle this for you. You can explicitly specify that the types of the arguments must be the same: (sig x-and-y (Fn [Int Int] Unit)).
2. If you're working in the dynamic part of carp defndynamic, macro, then yes, you might want a function like this and the Dynamic type should work -- we'll have to fix it if it indeed doesn't.

Hope this helps for now, and I'll try to get back to some of this stuff soon!