Turns out, this is a misunderstanding that I had about how Go dealt with types, which can be resolved by reading the relevant part of the spec: http://golang.org/ref/spec#Type_identity The relevant distinction that I was unaware of was that of named and unnamed types. Named types are types with a name, such as int, int64, float, … Read more
You can use the std::any::type_name function. This doesn’t need a nightly compiler or an external crate, and the results are quite correct: fn print_type_of<T>(_: &T) { println!(“{}”, std::any::type_name::<T>()) } fn main() { let s = “Hello”; let i = 42; print_type_of(&s); // &str print_type_of(&i); // i32 print_type_of(&main); // playground::main print_type_of(&print_type_of::<i32>); // playground::print_type_of<i32> print_type_of(&{ || “Hi!” … Read more
If you need to switch on the type of the outer interface{} you wont need reflection. switch x.(type){ case int: dosomething() } …but if you need to switch on the type of the attributes in an interface then you can do this: s := reflect.ValueOf(x) for i:=0; i<s.NumValues; i++{ switch s.Field(i).Interface().(type){ case int: dosomething() } … Read more
The creator of TypeScript explains how to create recursive types here. The workaround for the circular reference is to use extends Array. In your case this would lead to this solution: type Document = number | string | DocumentArray; interface DocumentArray extends Array<Document> { } Update (TypeScript 3.7) Starting with TypeScript 3.7, recursive type aliases … Read more
It appears that the type <method-wrapper ..> is used by CPython for methods implemented in C code. Basically the type doesn’t wrap another method. Instead it wraps a C-implemented function as an bound method. In this way <method-wrapper> is exactly like a <bound-method> except that it is implemented in C. In CPython there are two … Read more
Int to bool is easy, just x != 0 will do the trick. To go the other way, since Go doesn’t support a ternary operator, you’d have to do: var x int if b { x = 1 } else { x = 0 } You could of course put this in a function: func … Read more
JAXB provides two ways to accomplish this: 1. Inline Schema Anntotations You can use JAXB schema annotations to control the class names. <xs:schema xmlns:xs=”http://www.w3.org/2001/XMLSchema” xmlns:jaxb=”http://java.sun.com/xml/ns/jaxb” jaxb:version=”2.1″> <xs:complexType name=”itemType”> <xs:annotation> <xs:appinfo> <jaxb:class name=”Item”/> </xs:appinfo> </xs:annotation> <xs:attribute name=”id” type=”xs:string” use=”required”/> </xs:complexType> </xs:schema> 2. External Binding File This customization can also be done via and external binding file: … Read more
As of Rust 1.32 you can use {to,from}_{ne,le,be}_bytes for integral types. let begin = 1234_i32; let bytes = begin.to_ne_bytes(); let and_back = i32::from_ne_bytes(bytes); For floating point you still have to rely on prior methods.
The way sum is defined, the return value is open-ended; more than one type can implement the trait Sum<i32>. Here’s an example where different types for a are used, both of which compile: #[derive(Clone, Copy)] struct Summer { s: isize, } impl Summer { fn pow(&self, p: isize) { println!(“pow({})”, p); } } impl std::iter::Sum<i32> … Read more
You can use the std::any::type_name function. This doesn’t need a nightly compiler or an external crate, and the results are quite correct: fn print_type_of<T>(_: &T) { println!(“{}”, std::any::type_name::<T>()) } fn main() { let s = “Hello”; let i = 42; print_type_of(&s); // &str print_type_of(&i); // i32 print_type_of(&main); // playground::main print_type_of(&print_type_of::<i32>); // playground::print_type_of<i32> print_type_of(&{ || “Hi!” … Read more