How do I find out what a type alias is at compile time

[pd-giz-dave]

I have a type alias: pub type alias Float = f32 - this make it easy to change to f64 by a simple 1 line edit.
But I want to be able to tell at compile time if its set to f32 or f64 in a generic math function.
There is a compile time variable $alias that looks useful but I have no idea how to use it.
All my experiments result in either a compile time or build time error.
Any ideas on how to do this will be gratefully received.

[jorgeluismireles]

What about using sumtypes?. Go to https://play.vlang.io/p/3a7cb8718f and click Run.

type Float = f32 | f64

fn main() {
	mut fs := []Float{}
	fs << f32(3.14)
	fs << f64(3.141592)
	for f in fs {
		match f {
			f32 { println('${f} simple precision') }
			f64 { println('${f} double precision') }
		}
	}
}

[jorgeluismireles]

Much better:

import math

type Float = f32 | f64

fn main() {
	mut fs := []Float{}
	fs << f32(math.pi)
	fs << f64(math.pi)
	for f in fs {
		match f {
			f32 { println('${f} simple precision') }
			f64 { println('${f} double precision') }
		}
	}
}

[Wajinn]

In regards to the example given by jorgeluismireles, I wonder why some simple function is not provided and shown for giving the field/value as string, in addition to the type? Yes, match can do this, but seems like a built-in function for sum types should be available or shown.

There is typeof(fs).name (fs.type_name()), but no typeof(fs).field (or .value)/fs.type_value()?

[pd-giz-dave]

My objective is the main code does not know, or care, if its f32 or f64. So I do not want to litter the code with f32(...) but rather just Float(...) and its constant (either everything is f32 or everything is f64). I could do it via an env var and use -d ... but I'd rather it was all self contained in the source. Anyway, there are rare occasions when the compiler needs to know, e.g do I use math.sqrt() or math.sqrtf(). This is a performance critical app so I do not want to discriminate at run time and I want to avoid casting. Its a platform specific (Arm/Android) thing so I could do it via that. It would also be nice to have examples of using all those compile time variables, e.g. the documentation says "$alias matches type aliases" but what does that mean? I'd rather understand V than do a workaround. Sorry, a bit of a rant - but I really like V and I've been programming professionally for over 50 years in many languages, so me liking V really means something! :-)

…

On Wed, 9 Oct 2024 at 19:26, jorgeluismireles ***@***.***> wrote: Much better: import math type Float = f32 | f64 fn main() { mut fs := []Float{} fs << f32(math.pi) fs << f64(math.pi) for f in fs { match f { f32 { println('${f} simple precision') } f64 { println('${f} double precision') } } } } — Reply to this email directly, view it on GitHub <#22465 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AEEESAHV37ZSSPS3HBONZMDZ2VYLPAVCNFSM6AAAAABPUTL4XOVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTAOBZGU4DKMI> . You are receiving this because you authored the thread.Message ID: ***@***.***>

[medvednikov]

50 years :О I'm glad someone with your experience likes V.

Here's how you do it (taken from json2/decoder/decode.v)

} $else $if field.typ is $alias {
$if field.unaliased_typ is string {
	if value_kind == .string_ {
		value.$(field.name) = decoder.json[start + 1..end - 1]
	}

[medvednikov]

I'll update the docs

[pd-giz-dave]

There seems to be a gap in the compile time type info, I'm trying to do this:

// sqrt - call math.sqrt or math.sqrtf or math.sqrti as appropriate
@[inline]
pub fn sqrt[T](num T) T {
	// does not work
	$if T.typ is $alias {
		$if T.unaliased_typ is f32 {
			return math.sqrtf(num)
		} $else $if T.unaliased_typ is f64 {
			return math.sqrt(num)
		} $else {
			$compile_error('num is not f32 or f64')
		}
	}
	// works
	$if T is int {
		return math.sqrti(num)
	} $else $if T is f32 {
		return math.sqrtf(num)
	} $else $if T is f64 {
		return math.sqrt(num)
	} $else $if T is consts.Float { // ToDo: how to test Float as f32 or f64 at compile time?
		// assume f32 for now
		return math.sqrtf(num)
	} $else {
		$compile_error('num is not f32 or f64')
	}
}

consts.Float is defined as pub type alias Float = f32 in my consts module.
I can see from the json2 example how to take structs apart, but I have not got a struct.
I'd like to be able to get at CompileTimeTypeInfo for anything, not just struct fields, or am I missing something?

[felipensp]

There seems to be a gap in the compile time type info, I'm trying to do this:

// sqrt - call math.sqrt or math.sqrtf or math.sqrti as appropriate
@[inline]
pub fn sqrt[T](num T) T {
	// does not work
	$if T.typ is $alias {
		$if T.unaliased_typ is f32 {
			return math.sqrtf(num)
		} $else $if T.unaliased_typ is f64 {
			return math.sqrt(num)
		} $else {
			$compile_error('num is not f32 or f64')
		}
	}
	// works
	$if T is int {
		return math.sqrti(num)
	} $else $if T is f32 {
		return math.sqrtf(num)
	} $else $if T is f64 {
		return math.sqrt(num)
	} $else $if T is consts.Float { // ToDo: how to test Float as f32 or f64 at compile time?
		// assume f32 for now
		return math.sqrtf(num)
	} $else {
		$compile_error('num is not f32 or f64')
	}
}

consts.Float is defined as pub type alias Float = f32 in my consts module. I can see from the json2 example how to take structs apart, but I have not got a struct. I'd like to be able to get at CompileTimeTypeInfo for anything, not just struct fields, or am I missing something?

Take a look at decode_array_item() in vlib/x/json2/decoder.v

[pd-giz-dave]

Being inspired by reflection_sym_test.v I tried this:

		$if ((reflection.type_of(T).sym.info as reflection.Alias).parent_idx == typeof[f32]().idx) {
			return math.sqrtf(num)
		} $else $if (reflection.type_of(T).sym.info as reflection.Alias).parent_idx == typeof[f64]().idx {
			return math.sqrt(num)
		} $else {
			$compile_error('num is not f32 or f64')
		}

But that results in:

source/utils/utils.v:156:72: error: invalid `$if` condition: v.ast.SelectorExpr
  154 |         return math.sqrt(num)
  155 |     } $else $if T is consts.Float { // ToDo: how to test Float as f32 or f64 at compile time?
  156 |         $if ((reflection.type_of(T).sym.info as reflection.Alias).parent_idx == typeof[f32]().idx) {
      |                                                                              ~~
  157 |             return math.sqrtf(num)
  158 |         } $else $if (reflection.type_of(T).sym.info as reflection.Alias).parent_idx == typeof[f64]().idx {

It appears $if only understands the 'is' operator, but that expects type on the rhs so not useful here.
I tried using reflection.get_type(...parent_idx) is f32 but that did not work either:

source/utils/utils.v:156:7: error: invalid `$if` condition: expected a type or a selector expression or an interface check
  154 |         return math.sqrt(num)
  155 |     } $else $if T is consts.Float { // ToDo: how to test Float as f32 or f64 at compile time?
  156 |         $if (reflection.get_type((reflection.type_of(T).sym.info as reflection.Alias).parent_idx) or {$compile_error('cannot get type of alias')}) is f32 {
      |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  157 |             return math.sqrtf(num)
  158 |         } $else $if (reflection.type_of(T).sym.info as reflection.Alias).parent_idx == typeof[f64]().idx {