Idea: Improve typeof

[jasonkuhrt]

Question:

Why does typeof! [1,2,3] return 'Number'?

Idea:

Can we interchange typeof and typeof! so that the operator we know and hate can become the operator we know and love? The lesser of the two should be hidden behind alt syntax.

My only concern is not being able to typeof arrays as questioned above.

[gkz]

Use it as an expression

r = typeof! [1,2,3] #=> ["Number","Number","Number"]

[jasonkuhrt]

Better?:

• drop the confusing/inconsistent ! for a readable s
• fix typeof

o = {a:1  b:2  c:\b  d:[\nested  \array]}
a = [1  2  \a  \b  [\sub  \tree]  o]



typeof  o   #=> \Object
typesof o   #=> {a:\Number  b:\Number  c:\String  d:\Array}

typeof  a   #=> \Array
typesof a   #=> [\Number  \Number  \String  \String  \Array]



a-numbers = a |> filter (-> typeof it is \number)
a-numbers = typesof a |> filter (-> it is \number)

#=> [1, 2]
#=> {a:1  b:2}                (imagine o-numbers)



a-arrays  = a |> filter (-> typeof it is \Array)
a-arrays  = typesof a |> filter (-> it is \Array)

#=> [[\sub, \tree]]
#=> {d:[\nested  \array]}     (imagine o-numbers)

[satyr]

My only concern is not being able to typeof arrays as questioned above.

drop the confusing/inconsistent ! for a readable s

Note that typeof! and Unary Spread are separate features.

$ livescript -pe 'typeof!([1 2 3])'
Array

$ livescript -pe '^^[1 2 3]'
[ {}, {}, {} ]

[jasonkuhrt]

@satyr I'm mystified. Why do these produce different values?

typeof!([1,2]) #=> 'Array'
typeof! [1,2]  #=> ['Number', 'Number']

More importantly, can we improve the native typeof as exemplified above (namely 'Array' identification)? The plural form is sugar, not as important.

[vendethiel]

Because it triggers the unary spread.
+foo<[bar baz]> gives you [+foo['bar'], +foo['baz']]

[gkz]

Perhaps unary spread is no longer needed in LiveScript, and could be removed in order to have fewer special cases, as we can simply use operators as functions.

map (typeof!), [1, 2] #=> ["Number","Number"]

A bit longer yes, but I think worth it in reducing the amount of special cases a programmer needs to keep in mind.

[vendethiel]

I just think typeof! Shouldn't be unary spreaded. (I don't see why you'd use typeof! [...] anyway but ...)

[jasonkuhrt]

@gkz +1 reduce special cases (where the payoff is low).

And what about simply fixing the standard typeof?

map (typeof), [[1], [2]] #=> ["Array","Array"]

[michaelficarra]

@gkz: +1 get rid of unary spread. It's a neat feature, but leads to some confusing/unintuitive behaviours, and it's unnecessary as you say.

[vendethiel]

Like I said - Unary spread is really cool, removing typeof from unary spreading wouldn't be better ?
(and why would you write "typeof []" or "typeof [a, b, c]" in the first place ?)

[jasonkuhrt]

LiveScript typeof, in the future?

typeof some-array-value         # => 'array'
typeof 'boo'                    # => 'string'
typeof 5                        # => 'number'
...



# JavaScript code:

typeof$(someArrayValue)

function typeof$(value){
  if (Array.isArray(value)){
    return 'array'
  }else{
    return typeof value
  }
}

Simple.

[vendethiel]

(typeof! array)toLowerCase! here you go.

[jasonkuhrt]

@Nami-Doc Two versions of typeof that don't return the same values? This is just needlessly terrible, when you could easily have one that behaves as expected.

[vendethiel]

You may want the native version.