Hello, I'm trying to convert a c# function to f# and I'm having some unknown errors.

this is the original code
public T GetCustomAttribute<T>(Type type,bool inherit) where T:class
{
var attributes = type.GetCustomAttributes(typeof (T), inherit);
if (attributes.Length > 0)
return (T) attributes[0];
return null;
}

One of the attributes is defined as
[AttributeUsage(AttributeTargets.Class|AttributeTargets.Property)]
public class DetailsAttribute:Attribute
{
/// <summary>
/// The namespace to use when creating the new type
/// </summary>
public string Namespace { get; set; }
/// <summary>
/// True to wrap the text around new construct
/// </summary>
public bool AlwaysUseConstructor { get; set; }
/// <summary>
/// Not in use
/// </summary>
public IEnumerable<string> ConstructorParameters { get; set; }
}

My translation is as follows
For the attribute, I have
[<AttributeUsage(AttributeTargets.Class|||AttributeTargets.Property)>]
type DetailsAttribute() =
class
inherit Attribute()
///The namespace to use when creating the new type
let mutable ns = null
///True to wrap the text around the new construct
let mutable useConstructor = false
///Not in use
let mutable parameters:seq<string> = null
member x.NS with get():string = ns and set v = ns <- v
member x.UseConstructor with get() = useConstructor and set v = useConstructor <- v
member x.Parameters with get() = parameters and set v = parameters<- v
end

and my function (which is where I'm getting the errors) is defined as
1. let GetCustomAttribute<'T> (typ:Type) inherited =
let attributes = typ.GetCustomAttributes(typeof<'T>, inherited)
match attributes.Length with
| v when v > 0 -> attributes.[0] :?> 'T
| _ -> null
this does not compile.I get 2 errors
a. A type parameter is missing a constraint 'when 'T : null'
b. Explicit type parameters may only be used on module or member bindings

2. changing the definition to
let GetCustomAttribute<'T when 'T:null> (typ:Type) inherited =
gives just 1 error
error:: This code is not sufficiently generic. The type variable ^T when ^T : null could not be generalized because it would escape its scope

3. changing the definition from let to member gives the same error message as 2
member x.GetCustomAttribute<'T> (typ:Type) inherited =
or
member x.GetCustomAttribute<'T when 'T:null> (typ:Type) inherited =

4. This one works though and it appears the error from from the null in the code
member x.GetCustomAttribute<'T> (typ:Type) inherited =
let attributes = typ.GetCustomAttributes(typeof<'T>, inherited)
match attributes.Length with
| v when v > 0 -> Some(attributes.[0] :?> 'T)
| _ -> None
Now an error comes with the usage (that when I tried calling it from another member function)
member x.EncodeObject (data:obj) =
let noLazyLoad = x.GetCustomAttribute<DetailsAttribute> (data.GetType()) false
()

the portion 'T in the GetCustomAttribute function is underlined with the error message
error::This code is less generic than required by its annotations because the explicit type variable 'T' could not be generalized. It was constrained to be 'DetailsAttribute'.

The code portion: x.GetCustomAttribute<DetailsAttribute> (data.GetType()) false also gives a warning.

Lastly, this fails completely,
member x.EncodeObject (data:obj) =
let noLazyLoad = x.GetCustomAttribute<DetailsAttribute> (data.GetType()) false
let noLazyLoad2 = x.GetCustomAttribute<System.FlagsAttribute> (data.GetType()) false
()
with the error message
error:: A use of the function 'Json.GetCustomAttribute.2' does not match a type inferred elsewhere. The inferred type of the function is Json -> Type -> bool -> DetailsAttribute option. The type of the function required at this point of use is Json -> Type -> bool -> DetailsAttribute option This error may be due to limitations associated with generic recursion, i.e. type inference requires that generic functions and members are instantiated in only one way within their own recursive scope, e.g. within a 'let rec' collection or within a group of classes. Consider splitting these recursive bindings into two groups

What am I doing wrong? Thank you