NinjectWebCommon implementation/translation - C# to F# I've translated this code from c# and would like it to be more idiomatic f#:

namespace Foo.App_Start

open System
open System.Web

open Microsoft.Web.Infrastructure.DynamicModuleHelper

open Ninject
open Ninject.Web.Common

type NinjectResolver(kernel:IKernel) =
    let _kernel = kernel
    interface System.Web.Http.Dependencies.IDependencyResolver with 
        member this.BeginScope():Http.Dependencies.IDependencyScope = upcast this
        member this.GetService(t) =
            _kernel.TryGet(t)
        member this.GetServices(t)=
            _kernel.GetAll(t)
        member this.Dispose() = ()

//was static
[&lt;AbstractClass; Sealed&gt;]
type NinjectWebCommon () =
    static let bootstrapper = new Bootstrapper()

        /// &lt;summary&gt;
        /// Load your modules or register your services here!
        /// &lt;/summary&gt;
        /// &lt;param name="kernel"&gt;The kernel.&lt;/param&gt;
    //private static void RegisterServices(IKernel kernel)
    static let RegisterServices(kernel:IKernel) =
        System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver &lt;- new NinjectResolver(kernel)
        do()
        /// &lt;summary&gt;
        /// Creates the kernel that will manage your application.
        /// &lt;/summary&gt;
        /// &lt;returns&gt;The created kernel.&lt;/returns&gt;
        //private static IKernel CreateKernel()
    static let KernelCreation(kernel:IKernel) =
        System.Diagnostics.Debug.WriteLine "kernel Creation!"
        RegisterServices(kernel)
        let bs = fun () -&gt; new Bootstrapper()
        let kernelFun= System.Func&lt;IKernel&gt; (fun () -&gt; bs().Kernel)
        kernel.Bind&lt;System.Func&lt;IKernel&gt;&gt;().ToMethod(fun ac -&gt; kernelFun) |&gt; ignore
        kernel.Bind&lt;IHttpModule&gt;().To&lt;HttpApplicationInitializationHttpModule&gt;() |&gt; ignore
        let fetchedKernel:IKernel =System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver.GetService(typeof&lt;IKernel&gt;) :?&gt; IKernel
        fetchedKernel

    static let CreateKernel():IKernel =
        System.Diagnostics.Debug.WriteLine "standard kernel creating!"
        let kernel= new StandardKernel()  
//        
        try         //RegisterServices(kernel) |&gt; ignore;
            KernelCreation(kernel)
        with
            | ex -&gt; 
                System.Diagnostics.Debug.WriteLine "kernel disposing!"
                kernel.Dispose()
                raise ex


    /// &lt;summary&gt;
    /// Starts the application
    /// &lt;/summary&gt;
    static member Start() =
        DynamicModuleUtility.RegisterModule typedefof&lt;OnePerRequestHttpModule&gt; |&gt; ignore
        DynamicModuleUtility.RegisterModule typedefof&lt;NinjectHttpModule&gt; |&gt; ignore
        bootstrapper.Initialize(System.Func&lt;_&gt;(CreateKernel))
        System.Diagnostics.Debug.WriteLine "app Start()"
//        
//        
    /// &lt;summary&gt;
    /// Stops the application.
    /// &lt;/summary&gt;
    static member Stop() =
        System.Diagnostics.Debug.WriteLine "app stop"
        bootstrapper.ShutDown()


module DummyModuleToAttachAssemblyAttribute = 
    [&lt;assembly: WebActivatorEx.PreApplicationStartMethod(typeof&lt;NinjectWebCommon&gt;, "Start")&gt;]
    ////[assembly: WebActivatorEx.ApplicationShutdownMethodAttribute(typeof(FLochart.App_Start.NinjectWebCommon), "Stop")]
    [&lt;assembly: WebActivatorEx.ApplicationShutdownMethod(typeof&lt;NinjectWebCommon&gt;, "Stop")&gt;]
    do()
Your code seems like it's primarily plumbing. There are no algorithms or types that could be given the functional treatment. I have only two recommendations. 


Instead of NinjectWebCommon being abstract/sealed with static members you can make it a module with let-bound functions. 
_kernel in NinjectResolver is unnecessary because primary constructor parameters are available throughout the body of the type. So you can just reference kernel throughout instead.