@onetom i bet that’s why my boot reload doesn’t really work

@thedavidmeister i've prepared a minimal repo where you can play with reload https://github.com/onetom/boot-reloadable-hoplon (i used it to debug an error thrown from (reload :on-jsload true), but it turned out i was using boot-hoplon 0.2.2 instead of the latest 0.2.4, so there is no example of defonce in it yet)

@jumblerg i've also prepared a reload example specifically for hoplon ui: https://github.com/addplus/hoplon-ui-reload-example

i would be curious what do you think about this approach of having a cell as the content of body which i reset! on namespace reloads

Hello everyone, Im using ~ unquote in a formula cell to hoist another cell up, but I’d like to use this inside a macro, how can I prevent the macro from hoisting the cell until later in the formula cell?

seems like an extra ` does the trick? …. apparently not

@micha Is there an example somewhere which shows macro expansion in a formula context?

@flyboarder how do you mean?

javelin fully expands all macros in the formula before it does its own work, is that what you mean?

So to avoid evaluation of some-other-value I am using a macro

i don't think you want to use a macro there

oh ok, do you have another idea?

is the problem that some-other-val is a cell?

no, it uses pred, which will fail if pred is nil

i'm not following

you have a when pred there

the above will work, but if I try to use it in a function and pass in my route-params they are evaluated and it calls (fbdb/get-in (fb/post) (:id route-params)) which fails because route-params is nil at first

the whole get-in thing will throw an error if it doesnt get non-nil params

i don't see how it can get nils though, it's guarded by the when (:id route-params)

right but in a function call (fbdb/get-in (fb/post) (:id route-params)) is passed in as an arg, which evals it anyway, I was trying to write a macro to guard it

are you saying that (fb/post) is what is nil?

but the macro screws up my reset! because the cell is a value then

i don't see how it can be evaluated if (:id route-params) is nil

it will never get to the code that calls listen-once if (:id ...) is nil

if (fb/post) is nil you can just add that to the guard expr

i don't think macros will help because your problems are strictly runtime ones

I'd do add-watch here, doesn't that work?

@dm3 I havnt used add-watch before

assuming pred is a cell

(with-let [fbc (j/cell nil)]
  (add-watch pred
     (fn [_ _ old new] ;; not sure about args
        (when new
          (fbdb/listen-once ref (str/...) #(reset! fbc (db->clj %))))))

@dm3 interesting, ill have to play with that

@dm3 that will only watch one of that arguments tho right

yep

but you can deref ref there

I mean you should

I may not be able to guarantee that my incoming arguments are cells

they need to be watchable

not sure what's the right protocol in cljs

but I think it's possible to coerce them to that

you can make ref a cell that only changes when it's not nil

or do (when (and pred ref) ...

@micha ^ do you mean in my function or in the macro version?

in your function

there is not way to know if ref will be nil unless you evaluate it, of course

so (when (and pred ref) (stuff in here will not evaluate unless ref and pred are both not nil)) shoudl work

ah right, slight miss communication, ref is only either a value or throws an error, I would need to make this a macro to delay ref evaluation no?

if it’s a function it throws the error before entering my func

or just (try ref (catch js/Error _))

that will evaluate to nil in case an error is thrown

macros won't help when the issue is a runtime thing

a macro can't help you do anything you can't just do manually

because all it can do is generate code, which you can also just type yourself

right, ok so just to summarize, in a formula cell I can do this to eval things before the formula (cell= ~(things to pre eval)) but I cannot do that inside a macro (defmacro blah (cell= ~(things to pre eval)))

in a macro you probably want to use the formula fn instead of cell=

well maybe, it depends

your macro can also macroexpand its arguments, like the javelin one does

and I think thats whats happening which is why its a value not a cell anymore

that's why javelin does that, so that macros can compose

so if your macro will macroexpand its arguments before it generates its code you will be safe

alan and i have been planning to make a lisp where this is the default behavior, too

applicative order macros

this lets macros compose the way functions do in lisp

the macro doesn't know or care about macros in its arguments, just like a function doesn't know or care about the functions that might be evaluating to the values it gets as its arguments

That seems to be the way I default my thinking, why doesnt it just do this!?

however, if you can't solve the specific problem you have without macros first, then macros won't help you

macros can only generate some code at compile time

you need to know what code it needs to generate 🙂

You’d think there should be a way to specify if I want my argument evaluated when it is passed to my function, instead of either yes it’s evaluated (func) or no it’s not (macro)

like partial argument eval

in cljs it's not even between those two choices

in cljs you have compile time and runtime

and at compile time of course no cljs is evaluated

it's just a happy coincidence that cljs and clj both use the same type of ast (sexps)

but it's not like in clj where macros expansion is interleaved with evaluation

right because it’s all at compile time

cljs macros don't even run in cljs

they run in a completely different language

we just leverage the similarity of the two languages to make some things act as if you could write macros in the same language

but like in clj you can make a macro that uses a function defined in the same namespace

not so in cljs

@micha ok so trying to use formula this returns a function, which takes cells?

the arguments don't have to be cells

but if they are then it will react to changes in them

but i strongly recommend doing this manually first, before making macros

like if you can't hardcode it to fix your problem, the macro won't help at all

the macro just allows you to generalize the hardcoded solution

and the things you have to do to hardcode the solution will be the exact same things the macro will need to do, later

lol well it works so long as I dont put it in a function, this tells me my issue is when the arguments are evaluated

your macro will have to put them in a function then

if you decide to make a macro

it can't do anything you can't already do, all it can do is automate generating code

like generating a fn wrapper

or something like that

the compiler doesn't interleave with evaluation

so it has no impact on when things get evaluated

thats basically what im trying to do but im using ~ in my formula which doesnt work once it’s a macro

cant I delay ~ so it’s done by the formula not the macro?

~ isn't seen by formula

only cell= sees it

right cell= is what is in my current version

there is no need for ~ in formula, since you pass it args separately

cell= just generates an equivalent formula expression

(cell= (+ a b)) ;=> ((formula (fn [x y] (+ x y))) a b)

I will try to hardcode it as a formula version

and go from there

how do you call fbwhen-cell

^ in a let

what arguments do you give it

(hfb/fbwhen-cell (:id route-params) (fbdb/get-in (fb/post) [(keyword (:id route-params))]))

thats the issue, arg2 (fbdb/get-in (fb/post) [(keyword (:id route-params))]) needs to wait before it can eval

wait for what?

route-params not to be nil

why?

it throws an error

why not use a try/catch?

i never found a use for NPE yet in lisp

well any non-nil value isnt valid logic

so even if I catch the error I need to replace it with something

that something needs to exist in db

you can replace it with ::not-found or whatever

a distinct value that represents invalid data

but isn't an exception that will propagate up the call stack

yeah it seems that if I want to implement this as a function, I need to sanitize the argument inside and out of the function

throwing null pointer exceptions in lisp is rarely necessary or useful imho

like sanitize it outside to stop the error, and then again inside so make sure im not getting passed nil

that get-in function should just notthrow

instead of throwing it just returns :get-in/invalid or whatever

yeah but thats how the firebase library works

you don't need to do it that way though

just wrap it in a cljs function that doesn't throw

or monkeypatch it

^ good point, lol I can just do whatever with it 😛

@micha had a few 💡 makes much more sense now thanks!

🙂