Parameter-less Function is Treated as a Value when Composed about giraffe HOT 5 CLOSED

Remember, an HttpHandler looks like this:

HttpContext -> Async<HttpContext option>

So noParameterFunction() is executed, logs "Hello" and returns an HttpHandler that will print "Hello" when it is executed

Try this

let noParameterFunction ctx =
  async {
    printfn "Hello"
    return! text "Hello" ctx
  }

from giraffe.

@JonCanning is spot on

It can be very useful though for when you want to pre-compile data before returning the handler as the code body is only executed once at startup and does not need to be run each time.

If you remove currying, it is easy to see why the body only runs once as per below which is the same as yours only wrapping a ctx function:

let noParameterFunction () =
    printfn "Hello"
   /// val text : string -> HttpContext -> Async<HttpContext option>
    (fun ctx -> text "Hello" ctx)

although Jon's example is fine, you can just as easily avoid async wrap with

let noParameterFunction ctx =
    printfn "Hello"
    text "Hello" ctx

As there is no async binding other than the return, which is itself producing an async result. You only need to use async binding when your handler is itself doing some waiting, otherwise just return the async of the internal handler being used.

from giraffe.

Thank you for the explanation and workarounds. I am still not clear on why the code body only runs once. Is it because the HttpHandler is returning an Async result so all non async code is only evaluated once? I look at the curry-less version and I don't see why it would print "Hello" each time the function is called.

from giraffe.

This might help explain.
Every HttpHandler is a function, it takes in a HttpContext and returns Async<HttpContext option>, I find that a nice way to write all handlers, regardless of multiple inputs are

let functionValue =
    fun (ctx : HttpContext) -> // route execution runs from here
        printfn "Hello"
        text "Hello" ctx

let myText (txt:string) =
    fun (ctx: HttpContext) ->
         printfn txt
         text txt ctx

let preCompiled () =
     // only evaluted once when funtion called
     let serverStart = DateTime.Now.ToString()
     // now return a HttpHandler Function that contains reference to our value evaluated on startup
     fun ctx -> text serverStart ctx // route execution runs from here

The value webApp that contains all the routes and compositions is fully evaluated into a tree of HttpHandler functions that bind together, therefore expressions in your pipeline will evaluate till they return HttpHandlers to bind & Compose to the rest of the pipeline. It is similar to using the >> operator, composing two normal functions together into a pipeline, if you did fn1 = fn2 () >> fn3, provided the result of fn2 () is a function of the same type for the input of fn3, we can compose together into one fn1 function, but fn2 is never run again after initial execution as it has returned its function result.

from giraffe.

I got it now. The functions are evaluated so that they can be passed on to form the HttpHandler function. Thank you.

from giraffe.