fn assert_map[T]() {
    $if T is $map {
        assert true
    } $else {
        assert false
    }
}

fn assert_array[T]() {
    $if T is $array {
        assert true
    } $else {
        assert false
    }
}

fn assert_array_dynamic[T]() {
    $if T is $array_dynamic {
        assert true
    } $else {
        assert false
    }
}

fn assert_array_fixed[T]() {
    $if T is $array_fixed {
        assert true
    } $else {
        assert false
    }
}

fn assert_struct[T]() {
    $if T is $struct {
        assert true
    } $else {
        assert false
    }
}

fn assert_not_struct[T]() {
    $if T is $struct {
        assert false
    } $else {
        assert true
    }
}

fn assert_not_map[T]() {
    $if T is $map {
        assert false
    } $else {
        assert true
    }
}

fn assert_not_array[T]() {
    $if T is $array {
        assert false
    } $else {
        assert true
    }
}

fn assert_not_array_dynamic[T]() {
    $if T is $array_dynamic {
        assert false
    } $else {
        assert true
    }
}

fn assert_not_array_fixed[T]() {
    $if T is $array_fixed {
        assert false
    } $else {
        assert true
    }
}

struct Abc {}

struct Bc {}

struct Cd {}

fn test_kind_map() {
    assert_map[map[int]int]()
    assert_map[map[string]int]()
    assert_map[map[i64]i8]()

    assert_not_map[Abc]()
    assert_not_map[int]()
    assert_not_map[[]int]()
}

fn test_kind_array() {
    assert_array[[]int]()
    assert_array[[]f32]()
    assert_array[[]string]()

    assert_not_array[Abc]()
    assert_not_array[string]()
    assert_not_array[int]()
    assert_not_array[map[int]int]()
}

fn test_kind_array_dynamic() {
    assert_array_dynamic[[]int]()
    assert_array_dynamic[[]f32]()
    assert_array_dynamic[[]string]()

    assert_not_array_dynamic[Abc]()
    assert_not_array_dynamic[string]()
    assert_not_array_dynamic[int]()
    assert_not_array_dynamic[map[int]int]()
    assert_not_array_dynamic[[3]int]()
}

fn test_kind_array_fixed() {
    assert_array_fixed[[3]int]()
    assert_array_fixed[[5]f32]()
    assert_array_fixed[[6]string]()

    assert_not_array_fixed[Abc]()
    assert_not_array_fixed[string]()
    assert_not_array_fixed[int]()
    assert_not_array_fixed[map[int]int]()
    assert_not_array_fixed[[]int]()
}

fn test_kind_struct() {
    assert_struct[Abc]()
    assert_struct[Bc]()
    assert_struct[Cd]()

    assert_not_struct[int]()
    assert_not_struct[[]int]()
    assert_not_struct[map[int]int]()
}

//

type AliasOfAbc = Abc
type AliasOfint = int
type AliasOfstring = string

fn assert_alias[T]() {
    $if T is $alias {
        assert true
    } $else {
        assert false
    }
}

fn assert_not_alias[T]() {
    $if T is $alias {
        assert false
    } $else {
        assert true
    }
}

fn test_kind_alias() {
    assert_alias[AliasOfAbc]()
    assert_alias[AliasOfint]()
    assert_alias[AliasOfstring]()

    assert_not_alias[int]()
    assert_not_alias[f32]()
    assert_not_alias[[]int]()
    assert_not_alias[map[int]int]()
    assert_not_alias[Abc]()
}

//
fn assert_function[T](f T) {
    $if T is $function {
        assert true
    } $else {
        assert false
    }
}

fn assert_not_function[T](f T) {
    $if T is $function {
        assert false
    } $else {
        assert true
    }
}

fn test_kind_function() {
    assert_function(test_kind_function)
    assert_not_function(123)
    assert_function('abc'.contains)
    assert_function(5.str)
}