import math { max,
	min,
}

import cli { Command }
import math.complex { complex, Complex }
import os {
	input, user_os, file_ext }

import mod {
	Unused,
	StructEmbed, StructField, StructRefField
	StructMapFieldKey, StructMapFieldValue,
	StructArrayFieldElem, StructFixedArrayFieldElem
	StructMethodArg,
	StructMethodArgGeneric,
	StructMethodRet,
	StructMethodRetGeneric,

	InterfaceField,
	InterfaceMethodArg,
	InterfaceMethodRet,

	FnArg,
	FnArgVariadic
	FnArgGeneric
	FnArgTypeParam1
	FnArgTypeParam2
	FnRet,
	FnRetGeneric
	FnRetTypeParam1,
	FnRetTypeParam2,

	RightOfIs,
	RightOfAs,

	AliasTarget,
	SumVariant1, SumVariant2,
	FnAliasParam, FnAliasRet

	Enum
}

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))
}