anchor.diff:          }
   
   /// Renders partial content
  -let partial<'a> path (model : 'a) =
  +let partial<'a> (path:string) (model : 'a) =
       fun r ->
           async {
  -            let templatePath = resolvePath r.runtime.homeDirectory path
  -            let! writeTime, razorTemplate = loadTemplateCached templatePath
  -            let cacheKey = writeTime.Ticks.ToString() + "_" + templatePath
  -            return razorService(r.runtime.homeDirectory).RunCompile(razorTemplate.ToString(), cacheKey, typeof<'a>, model) |> replaceResources
  +            let serviceConfiguration = TemplateServiceConfiguration()
  +            serviceConfiguration.DisableTempFileLocking <- true
  +            serviceConfiguration.CachingProvider <- cachingProvider
  +            serviceConfiguration.TemplateManager <-
  +              { new ITemplateManager with
  +                  member x.AddDynamic(_, _) = failwith "not implemented"
  +                  member x.Resolve key =
  +                    let _, readTemplate = loadTemplate key.Name |> Async.RunSynchronously
  +                    LoadedTemplateSource(readTemplate, key.Name) :> _
  +                  member x.GetKey (name, resolveType, context) =
  +                    NameOnlyTemplateKey(name, resolveType, context) :> ITemplateKey }
  +
  +            let razorService = RazorEngineService.Create(serviceConfiguration)
  +            return razorService.RunCompile(path, typeof<'a>, model) |> replaceResources
           }
   
   /// Renders nested content
  
positive.code: 
  open System
  open System.Text.RegularExpressions
  open Suave.Http
  open Suave.Utils.AsyncExtensions
  open RazorEngine.Templating
  open System.Globalization
  open System.Threading
  open Suave.Files
  open Suave
  open System.IO
  open RazorEngine.Configuration
  
negative.code:       return writeTime, razorTemplate
      }
  
  let private cachingProvider = new InvalidatingCachingProvider(fun t -> ())
  
  /// Renders partial content as empty string
  let empty<'a> = 
  