jsonnet std.type(x) implements in cuelang ?

[cueckoo]

Originally opened by @morlay in cuelang/cue#885

I need to check some untyped value like jsonnet std.type(x) did.

this version works

_type: {
	#x: _

	_canArray:  (#x & [...]) != _|_
	_canObject: (#x & {[string]: _}) != _|_
	_canNull:   (#x & null) != _|_
	_canString: (#x & string) != _|_
	_canFloat:  (#x & float64) != _|_
	_canInt:    (#x & int64) != _|_
	_canBool:   (#x & bool) != _|_

	// std.isArray(x)
	if _canArray && !_canObject {
		"array"
	}

	if _canNull && !_canObject {
		"null"
	}

	// std.isObject(x)
	if _canObject {
		"object"
	}

	// std.isString(x)
	if _canString {
		"string"
	}

	// std.isNumber(x) not fully supported.
	if _canFloat && !_canInt {
		"float"
	}

	if _canInt {
		"int"
	}

	// std.isBoolean(x)
	if _canBool {
		"bool"
	}
}

#values: [
	[""], // array
	{{}}, // object
	"",   // string
	1,    // int
	1.1,  // float
	true, // bool
	null, // null
]

valueAndTypes: [
	for x in #values {
		[x, (_type & {_, #x: x})]
	},
]

is there a more simple way to do this ?

[cueckoo]

Original reply by @mpvl in cuelang/cue#885 (comment)

This, I guess:

_type: 
	{#x: [...], "list" } |
	{#x: {...}, "object" } |
	{#x: null, "null" } |
	{#x: string, "string" } |
	{#x: float, "float" } |
	{#x: int, "int" } |
	{#x: bool, "bool" }

#values: [
	[""], // array
	{}, // object
	"",   // string
	1,    // int
	1.1,  // float
	true, // bool
	null, // null
]

valueAndTypes: [
	for x in #values {
		[x, (_type & {_, #x: x})]
	},
]

We're working on a proposal for a shorthand syntax for this macro use of structs, that would allow you to write:

_type:
	{#0: [...], "list" } |
	{#0: {...}, "object" } |
	{#0: null, "null" } |
	{#0: string, "string" } |
	{#0: float, "float" } |
	{#0: int, "int" } |
	{#0: bool, "bool" }

#values: [
   // same
]

valueAndTypes: [
	for x in #values {
		[x, _type(x)]
	},
]

[cueckoo]

Original reply by @morlay in cuelang/cue#885 (comment)

Cool example ！！！

Seems I could implements switch - case statement in cuelang now 😄

Looking forward to the shorthand syntax.
it could be neater.