Typed function as generic argument fails to compile

[eptx]

Not sure why this simple compose() attempt fails to compile. Is this a bug or am I not constructing the functions or types correctly?

type Fint = fn (int) int
type FT = fn (T) T

fn v(i int) int {
	return i + 1
}

fn composei (fns ...Fint) Fint {
	return fn [fns] (i int) int {
        mut r := i
		for f in  fns {
			r = f(r)
		}
		return r
	}
}

fn compose<T> (fns ...FT) T {
	return fn [fns] <T>(i T) T {
        mut r := i
		for f in  fns {
			r = f(r)
		}
		return r
	}
}

println(v(v(v(0))))
println(composei(v, v, v)(0))
println(compose(v, v, v)(0)) // <---- offending call

Results in ...

code.v:32:17: error: cannot use `fn (int) int` as `fn (T) T` in argument 1 to `compose`
   30 | println(v(v(v(0))))
   31 | println(composei(v, v, v)(0))
   32 | println(compose(v, v, v)(0))
      |                 ^
   33 |
Exited with error status 1

[eptx]

Was able to use sum types to create a modest pipe function...but not generic types. Improvements welcome.

type Tp =  string | int
type FT = fn (Tp) Tp

fn pipe(fns ...FT) FT {
	return fn [fns] (i Tp) Tp {
        mut r := i
		for f in  fns {
			r = f(r)
		}
		return r
	}
}

fn v(i Tp) Tp {
    match i  {
        int {return i + 1}
        string {return i + "1"}
    }
}

fn tupper(s Tp) Tp {
    return 
    	match s {
            string {s.to_upper()} 
            else {s}
    	}
}

fn dbl() fn (Tp) Tp {
    f := fn (i Tp) Tp {
        match i {
            string {return i + i }
            int {return i + i }
        }
    }
    return f
}

string_pipeline := pipe(v,dbl(),tupper)
assert string_pipeline('ab') as string == 'AB1AB1'
assert pipe(v,dbl())(3) as int == 8