import math { max, min }
import cli { Command }
import math.complex { Complex, complex }
import os {
	file_ext,
	user_os,
}
import mod {
	AliasTarget,
	Enum,
	FnAliasParam,
	FnAliasRet,
	FnArg,
	FnArgGeneric,
	FnArgTypeParam1,
	FnArgTypeParam2,
	FnArgVariadic,
	FnRet,
	FnRetGeneric,
	FnRetTypeParam1,
	FnRetTypeParam2,
	InterfaceField,
	InterfaceMethodArg,
	InterfaceMethodRet,
	RightOfAs,
	RightOfIs,
	StructArrayFieldElem,
	StructEmbed,
	StructField,
	StructFixedArrayFieldElem,
	StructMapFieldKey,
	StructMapFieldValue,
	StructMethodArg,
	StructMethodArgGeneric,
	StructMethodRet,
	StructMethodRetGeneric,
	StructRefField,
	SumVariant1,
	SumVariant2,
}

type Alias = AliasTarget
type SumType = SumVariant1 | SumVariant2
type Fn = fn (FnAliasParam) FnAliasRet

struct Struct {
	StructEmbed
	v         StructField
	ref       &StructRefField
	map       map[StructMapFieldKey]StructMapFieldValue
	arr       []StructArrayFieldElem
	arr_fixed [2]StructFixedArrayFieldElem
}

fn (s Struct) method(v StructMethodArg) StructMethodRet {
	return StructMethodRet{}
}

fn (s Struct) method_generic[T](v StructMethodArgGeneric[T]) StructMethodRetGeneric[T] {
	return StructMethodRet[T]{}
}

interface Interface {
	v InterfaceField
	f(InterfaceMethodArg) InterfaceMethodRet
}

fn f(v FnArg, vv ...FnArgVariadic) FnRet {
	if v is RightOfIs {
	}
	_ = v as RightOfAs

	println(Enum.val)

	return FnRet{}
}

fn f2(v Generic[FnArgTypeParam1, FnArgTypeParam2]) Generic[FnRetTypeParam1, FnRetTypeParam2] {}

fn f_generic[T](v FnArgGeneric[T]) FnRetGeneric[T] {
	return FnRetGeneric[T]{}
}

struct App {
	command &Command
}

struct MyCommand {
	Command
}

fn imaginary(im f64) Complex {
	return complex(0, im)
}

fn main() {
	println(max(0.1, 0.2))
	println(min(0.1, 0.2))
	println(user_os())
	println(file_ext('main.v'))
	println(imaginary(1))
}