Would it be possible to use the same flags, when recompiling, as those defined in the fsproj?
Or at least be able to define custom symbols to use when launching the watcher.

For instance, this code will evaluate differently between MSBuild and the Interpreter when the symbol WITH_TRACE is defined in the fsproj.

let updateData () =
    (...)
#if WITH_TRACE
    do sendTraceToExternalService()
#endif

I know it can be difficult because it depends on the configuration (Debug, Release) and platform (Android, iOS) used when running the project with the IDE.

But without it, it makes using the interpreter really complicated on bigger than small projects.

A better example that made me realize this:

I'm trying to use Fabulous.LiveUpdate with ElmishContacts (a Fabulous app)
The interpreter doesn't like SQLite and prints a compilation error (no member found).
Ok, why not, maybe it's asking too much.

So I made a "design time" mock for data access, switching the 2 relies on a custom symbol (ENABLE_LIVEUPDATE)
But this doesn't work as the interpreter will remove the #if ENABLE_LIVEUPDATE block.
A workaround can be using the negative #if !ENABLE_LIVEUPDATE but for more advanced scenario where an actual symbol is expected, it won't be possible.

Hi, I've maintained an F# language server for a while, and the fiddliest part is cracking project files.

Is ProjectCracker.fs intended to be a general-purpose .fsproj => f# compiler options converter? Or is it only meant to crack the kind of .fsproj files that are used in Fabulous?

If an interpreted type inherits from a compiled type you can't create an instance of that type

'Cannot create an instance of DiffSharp.Model.Model because it is an abstract class.'

This is because the interpreter doesn't have a "real" class for the interpreted type and instead tries to use delegation to the inherited object.

Only current workaround is to modify code to inherit from a non-abstract type

humhei/FCSWatch#8

Hi,

Following the guide of Fabulous Live Update and Giraffe.HotReload, I'm trying to implement HotReload for Bolero Elmish. I've been able to successfully resolve the "update" function from the MVU pipeline, but when I call the erased function, the following exception occurs:

What's interesting is that it's resolving the actual union value, rather than the structure describing it.

The code I'm attempting to hot reload is as follows:

type Model =
    {
        value: int
    }

let initModel =
    {
        value = 0
    }


type Message =
    | Increment
    | Decrement

let update (message : Message) (model : Model) =
    match message with
    | Increment ->
        { model with value = model.value + 1 }, Cmd.none
    | Decrement ->
        { model with value = model.value - 1 }, Cmd.none

let view model dispatch =
    concat [
        button [on.click (fun _ -> dispatch Decrement)] [text "-"]
        span [] [textf " %i " model.value]
        button [on.click (fun _ -> dispatch Increment)] [text "+"]
    ]


type Updater(update) =
    member __.UniqueUpdate message model = update message model

let myHotReload = Updater(update)

And the code that is resolving the myHotReload value:

    let handleUpdate (updater : ProgramUpdater<'msg, 'model>) (files : (string * DFile)[]) =
        printfn "Created interpreter! %A" interpreter

        lock interpreter (fun () ->
            files |> Array.iter (fun (fileName, file) -> interpreter.AddDecls file.Code)
            files |> Array.iter (fun (fileName, file) -> interpreter.EvalDecls (envEmpty, file.Code))
          )

        let mem = tryFindMemberInFiles "myHotReload" files
        match mem with
        | Some (def, expr) ->
            try
                printfn "Found member!"
                let entity = interpreter.ResolveEntity(def.EnclosingEntity)
                printfn "Got entity! %A" entity

                let (def, memberValue) = interpreter.GetExprDeclResult(entity, def.Name)
                printfn "Got member value! %A" memberValue

                let value = getVal memberValue
                printfn "Got Value!: %A" value

                match value with
                | :? ObjectValue as x ->
                    let (ObjectValue v) = x
                    let updater = Map.find "update" v.Value

                    printfn "Found update %A" updater
                    let erasedUpdater = updater :?> obj -> obj -> obj * Cmd<obj>

                    printfn "Successfully cast: %A" erasedUpdater
                    let model = initModel
                    let message = Message.Increment

                    printfn "Calling update"
                    let newSet = erasedUpdater message model
                    printfn "Got new value %A" newSet
                | :? Updater as updater ->
                    printfn "Found Updater!"
                    let model = initModel
                    let message = Message.Increment

                    printfn "calling Updater!"
                    let newSet = updater.UniqueUpdate message model
                    printfn "Got new values! %A" newSet

            with e ->
                printfn "Got exception: %A" e

        | None ->
            printfn "could not find member"

More interesting details, the value here is resolving as an ObjectValue rather than as the Updater type as I expected. I've tried resolving the update function various ways as well, packaged in a type, as a method itself, however I always receive the previously mentioned exception.

I'm not sure if there is an issue in the way I'm resolving the types, or a bug in the interpreter, any advice or help would be greatly appreciated. Thanks :)

EDIT:

Update, the reason the object was resolving as ObjectValue is because of how I set up my projects, I've fixed that now, but the issue still remains.

I have a model like this:

    type Model =
        {   Player : Sprite option
            Elapsed : TimeSpan
            Game: Game option
            SpriteBatch: SpriteBatch option 
            }

I seem to get to a point in interpreting where the model in null in the env, this is where the view contains access to dotted external types (model.Game) :

    let view (model: Model) (dispatch: Msg -> unit) =
        printfn "updating view 5"
        match model.Game with
        | Some game -> game.GraphicsDevice.Clear Color.Blue
        | _ -> ()

Any pointers?

Currently it appears Fabulous.LiveUpdate done not support 4.7 Language Features such as implicit yields from Lists.

When using Fabulous.LiveUpdate, when using implicit yields from (for example) View.StackLayout(, children = []), the LiveUpdate PortaCode returns errors like:

C:\Users....\App\Screen.fs (734,37)-(734,99) typecheck warning This expression returns a value of type 'ViewElement' but is implicitly discarded. Consider using 'let' to bind the result to a name, e.g. 'let result = expression'. If you intended to use the expression as a value in the sequence then use an explicit 'yield'.

Compiling, running, debugging the App works fine but in the emulator and on real hardware.

Expected Result: PortaCode should use the same compiler version as being used by the project to compile.

The readme is saying that a --watch flag exists but it is not documented in the arguments list.

Hi, I was working on incorporating this into a Giraffe extension to allow for hot-reload of giraffe views and I was able to get an MVP going very quickly thanks to the examples over on the Fabulous repo. As it is, I've been very successful finding a value of a given name and testing if it meets certain types and coercing that into a shape I need to make a Giraffe HttpHandler. What I'm having trouble with is a more general mechanism to resolve an HttpHandler.

What I'd like to be able to resolve, at minimum, are:

• value named XXXX of type HttpHandler
• value/member named XXXX of some F# function type whose final return type is HttpHandler. For these I would like to be able to determine the types of the parameters so I can retrieve them via the Asp.Net Core dependency injection mechanisms and then apply them to the actual function.

For this second case I've had a hard time going from FSharp.Compiler.PortaCode.Interpreter+MethodLambdaValue to some kind of one-level-higher form of the member. Do you have any pointers or resources I can look at to help?

Mirroring the issue I logged in FCSWatch for observable support.

humhei/FCSWatch#38

The reason I needed this was a subscription after initialisation is needed to restart the event loop after a hot reload.

Sort of like this:

    let subUpdateLoop (game: ElmishGame) dispatch =
        let msgSender msg = msg |> Tick |> dispatch
        game.UpdateEvent.Add(msgSender)

    let init game = 
        initModel game, Cmd.ofSub (subUpdateLoop game)

Im curious on the purpose of the interpreter?

Right now our team is placing most of the time into developing the UI for our Fabulous app, and the build/deploy time is around 2 minutes, so we are trying to use LiveUpdate. At the same time we are using FSharp.Data JsonProvider across the application, for instance ABCTypeProvider.Root often times ends up in the Model.

The compilation on the build machine goes fine, but when porta code is run by the interpreter on the application host (android emulator) this is the error that happens
ERROR SENDING TO WEBHOOK: "System.Exception: error converting rhs of init System.InvalidOperationException: the type 'Root' does not have a qualified name

I assume the problem is that type gets erased and since it is referenced in the Model it does not work. But it really sucks and I am trying to get it to work

Tried:

• Moving the TypeProvider definitions to a separate project (did not work, again, it is referenced in the Model and the accessors are used within the update/view functions.

Contemplating:

0. Try to use --livechecksonly
1. Somehow prevent the type to be erased

• Is this even possible? From my limited type provider understanding the designer of the provider makes the decision weather to erase the type or not
• Maybe there are some interresting [<type: ABCAttrribute>] that will prevent erasure
• Supply options to the type provider 'constructor'

2. Choose a different type provider implementation that does not erase the type
3. Relax the type constraints to obj and have helpers to access the fields of the type (all in the separate util project)

New idea:

If the code is first compiled by FSharp.Compiler.Service maybe figure out why it does not erase the types (assumption) as well as regular VS build process does

I think I will do more research on number 1 and if I fail proceed with 3.

Any suggestions on a good way to troubleshoot this?