How to upgrade from an old version of MSR?

[LibraSun]

Tough call. I would say no to new features like that unless and until a recognizable minority of users requests them, which I doubt will ever happen. Diminishing returns on your time.

I also doubt most people will be writing complex expressions of the types I've been testing lately, but I was merely trying to flush out any incipient engine problems.

I'm glad these submissions have been equal parts entertaining and instructive, rather than an annoyance.

[toggledbits]

Agreed. I think that comparison of objects would be rarely used. Mostly, it seems, the expression language is used for access data in structures (like HTTP responses and entity attributes), and moving that around; simple calculations (like random delays) seem to be common; and finally, although I haven't seen it come up in MSR, is going to be time-series stuff. I've not seen a case in either MSR or RFV for object/array comparison.

Now, float equality, yes, I have seen that, but generally speaking, they have been involved in magnitude comparisons (< and > with or without =), and that makes the round-off errors less consequential. So agree no pressing need there, either.

To reiterate, everything you have thrown at me here is valuable, turning either into documentation changes, or a bug fix and an additional regression test.

[LibraSun]

PRO TIP (inspired by preceding reply):

WHEN PERFORMING EQUALITY TESTS among Float (high-precision) Expressions (variables) in MSR, use this format:

1. First, create a Global Expression such as epsilon with value 0.001 (or any smaller positive value sufficiently close to 0);
2. Rather than the test (A==B), where at least one of the variables is a Float, use (abs(A-B)<epsilon) instead.

This avoids the chance of a phony FALSE due to mantissa rounding by the calculation engine.

[LibraSun]

QUICK CONVERSION FROM DECIMAL (number) TO BINARY (string)

If your workflow demands a binary representation (e.g. you're using Switchboard plug-in's bit-masking features to control multi-switch status) and you really want to see 0's and 1's instead of MSR's always-decimal output, try this Expression on for size:

binConvert :=

b=13,
res=[1&b>>3,1&b>>2,1&b>>1,1&b],
join(res,"")

Result: 1101

NOTE: Here I've used only 4 "bits" but the concept generalizes to arbitrarily many bits, to accommodate larger inputs.

BONUS: if you want to round-trip a binary string into its decimal numeric equivalent, this Expression will get you there:

decConvert :=

B="001101",
binStr="0b"+B,
0b111111 & binStr

Result: 13 (decimal)

In this case, I've chosen 6 bits, but you could employ more or less to suit the length of your input string.

[LibraSun]

@toggledbits , I notice that the expression

A = [1,2,3], push(A,A)

does not generate an error (it should, since push(a,b) expects a non-object in b), nor does it generate a result. Just limbo.

[toggledbits]

This will fall into the categories of "don't do this" and "will not be fixed". The reason is objects (which arrays are) pass by reference so that (in more typical usage) push(A, 55) can fulfill its definition: modifying A in place by appending 55 to it. An attempt to fix it would result in having to pass copies of the arguments (pass by value), which means the first argument then is not A, but rather a copy of A, and then push() is modifying the copy in place and not the original array, so the original array never changes, defeating the purpose of the function.

[LibraSun]

Forging ahead with more newfangled expressions...
@toggledbits what would you expect from:

a=["a","b","c"], b=["d","e"],
each val in b: push(a,val)

My money was on:
["a","b","c","d","e"]
but instead I got:
[["a","b","c","d","e"],["a","b","c","d","e"]]

EDIT: Ah, here's the magic sauce:

a=["a","b","c"], b=["d","e"],
each val in b: c = push(a,val), c

Result: ["a","b","c","d","e"]

[LibraSun]

While you're here...

testArr = [1,2],
first m in testArr with m <= 2
Result: (number) 1 // correct results since 21089+

[LibraSun]

@toggledbits , I see the immediately-above situation has been rectified with 21090, so I'll edit accordingly.

I also see that you've instantiated some of the array- and text-handling functions you mentioned earlier, so THANK YOU!

For example:

concat( [1] , [2] ) now yields [1,2]
slice( [1,2,3] , 1 , 2 ) now yields [2,3]
pop( [1,2,3] ) now yields 3
push( [1,2,3] , 5 ) now yields [1,2,3,5]
shift( [1,2,3] ) now yields 1
unshift( [1,2,3] , 5 ) now yields [5,1,2,3] // NOTE: currently only permits a single addend; for instance, unshift( [1],2,3,4 ) results in [2,1] not [2,3,4,1]!

[LibraSun]

This one has me scratching my head a bit:

b = [ ] , each i in a = [ 1 , 2 ] : do push( b , i ) , push( b , i ) done

// yields [[1,1,2,2],[1,1,2,2]]
// expecting [1,1,2,2]

while this modified version:

b=[],each i in a=[1,2]: do push(b,i) done

// yields [[1,2],[1,2]]
// expecting [1,2]

[toggledbits]

The result of push is an array.

[LibraSun]

@toggledbits said in Expressions and LuaXP Functions:

The result of push is an array.

But if you

push ( [ ] , 1 )

shouldn't you get [ 1 ]? And not [ [ 1 ] , [ 1 ] ]?

[toggledbits]

It depends on what the complete expression is. Remember that the value of each is every non-null expression result during the iteration. So an array of arrays is a very possible response.

[LibraSun]

@toggledbits Unless I'm mis-reading the way each works, I had anticipated the underlying interpretation of:

b=[],each i in a=[1,2]: do push(b,i) done

to be as follows:
"Start with an empty array named b. For each item in the array named a, starting with 1, append that value into array b. First, you would get [ 1 ], and the next iteration, using the 2 from a, append that to b to yield [ 1 , 2 ]."

Any I missing an important piece of the puzzle? (I do recognize that do/done is not necessary here, but I left it in for direct comparison with the expression immediately preceding.)

Thanks. Sorry to give you grief over these operations.

[toggledbits]

If you want to see what b looks like at the end, you need to do this:

b=[],each i in a=[1,2]: do push(b,i) done, b

If you don't (which is how you've done it so far), you are seeing the result of each, which is an array, and since each expression within the each has resulted in an array, the result of that each is therefore an array of arrays, and referring to the same array by reference.

[LibraSun]

Makes perfect sense now. Thanks!

[LibraSun]

This one seems to evade the purpose of isnull() somehow:

isnull(1/a) // returns false

whereas

isnull(a) // returns true, as expected

In both cases, a is undefined.

I also cannot seem to create an expression that results in true for isNan(), no matter what I throw at it.

Finally, why would bool(null) return TRUE?

[Elcid]

isNaN([1,2,3]) and isNaN("ten"/2) and isNaN("ten" + "eight") are all true

[toggledbits]

null coerces to zero (0) for arithmetic operations, so 1/null is infinity which is not null.

int("abc") results in NaN which will return isNaN(int("abc"))==true

bool(null) should return false and I will fix it.

Edit: just to follow up, I've added Infinity as a keyword/value to the grammar, with a supporting isInfinity(value) test function (you can also test via value === Infinity), and added that to the documentation for the next release/build. And bool(null) is fixed. FYI, bool() takes a slightly deeper view of "truthiness" than JavaScript natively: the values (number) 0, null, empty string ("") and NaN are false as in JavaScript, but so additionally in lexpjs/Reactor are string "0", string "no", string "off", and string "false"; any other value of any type is true (including empty arrays and objects).

[LibraSun]

MSR RECIPES: Compact object-based message composer

Several of my Rules send out SMTP emails, and I'm always looking for a compact method of composing these outbound messages, using the fewest expressions along with a simple "mail merge" template. Here's a two-variable approach you might consider:

msgBody ► "This is my message." 
// leave blank if msgBody will be set by other Rules

msgTemplate ► 
tmp = {hdr:"Header here" ,  msg:msgBody ,  ftr:"Footer here" ,  crlf:"\n"},
send = {message:tmp.hdr+tmp.crlf+tmp.msg+tmp.crlf+tmp.ftr} , send.message

I hope this can be adapted to your workflow somehow!