A most harrowing collection of Julia WATs

General Usage
1

Hello all! :wave:
I’ve been collecting a few of the most cursed corner cases of Julia WATs that I know of here (WIP), but I would appreciate if people could share their own rare specimens as well.

Please ping me with your contributions and I’ll post with proper credit.

Here’s an example of what I mean by a Julia WAT:

julia> e = 9998.0
9998.0

julia> 2e
19996.0

julia> 2e+4
20000.0

julia> 2e+5 # This should be 20001.0, right?
200000.0

julia> 2e + 5 # note the spacing
20001.0

…wat.

Some of these are just unavoidable corner cases of multiple design constraints, others are an artifact of parsing being hard, but they’re all supposed to be tongue-in-cheek puzzles of our dear JuliaLang <3.

27 Likes
2

I mean, as a scientist I did not understand the point until the last line, because the 2e+4 immediately was parsed by my mind as a number in scientific notation and I did not understand the relation with the previous e or what you did mean by your first comment.

Surely there are some Julia WATs, but this seems kinda expected from any language with both floating points and implicit multiplication, is Julia the only language with these two characteristics?

16 Likes
3

Interestingly, syntax highlighting makes it hard to understand the wat

13 Likes
4

See also Bogumił Kamiński’s

Pitfalls of macro invocation in Julia

julia> macro m(args...)
           show(args)
       end
@m (macro with 1 method)

julia> @m 1 + 1
(:(1 + 1),)
julia> @m 1+1
(:(1 + 1),)
julia> @m 1 +1
(1, 1)
8 Likes
5

I always thought allowing things like 2x (instead of requiring 2*x) was just setting up things to fail in
unexpected ways. Wat!?

15 Likes
6

One of your WATs isn’t quite true:

image
image1103×342 61.2 KB

1 Like
7

However, the other example of “Shadowing” does reproduce the error shown that Kristopher Carlsson pointed out:
image

8

Probably because you already used - in your session

8 Likes
9

One from many on another of Bogumił Kamiński’s blog posts

julia> isequal(sum([-0.0, -0.0]), sum([-0.0, -0.0], init=0.0))
false
7 Likes
10

Ah, thanks @giordano, looks like you’re right:

image
image952×396 80.2 KB

1 Like
11

Great collection! A couple of comments though:

  • “and, or on empty collections”: not spelled out, what is the WAT? Or is it really in reference to the “broadcasting shenanigans” below it?
  • “what is this syntax?” I’m not sure what’s wrong with it.
julia> f = function(x) x+1 end
#11 (generic function with 1 method)

julia> f(3)
4

It’s just a way to declare an anonymous function—IMO it’s an elegant syntax because it makes it very clear that what you’re doing is not assigning a name to the function.

9 Likes
12

That looks perfectly fine to me, no surprise if it behaves like arrays.

13

This is well documented in ?isequal

..
 julia> 0.0 == -0.0
 true

 julia> isequal(0.0, -0.0)
 false
..
4 Likes
14

Another one for the shadowing category

julia> Iterators = (map = (f, x)->f.(x).^2,)
(map = var"#1#2"(),)

julia> Iterators.map(identity, 1:5)
5-element Vector{Int64}:
  1
  4
  9
 16
 25

It’s a bit contrived, but actually happened to me in a different way because I accidentily pasted a compat requirement into the REPL…

2 Likes
15

For me it was that I thought that the anonymous function syntax was only valid using ->, so this came as a surprise.

Looking at it, I also like it too now :stuck_out_tongue_winking_eye:

julia> const a = (function(x)
    # more code
    x^2
end)(2)
4

julia> const b = ((x) -> begin
    # more code
    x^2
end)(2)
4

It is more readable for in-place functions (although I don’t know if people use them, maybe for some initializer).

2 Likes
16

Thanks for the comments @tim.holy !

Yes, those comments are basically TODOs that I pepper in my blogposts and as I come back to them I overwrite them - perhaps the big :construction: WIP :construction: signs should be a bit more prominent.

And although I agree with your comments on the anonymous function syntax - it definitely made me say “WAT? You can do that?” when I first saw it, so I’m guessing it’s gonna punk other people too on their first encounter.

1 Like
17

Miguel

This code is inefficient when called with an integer argument:

function f(x)
    x += 1
    x /= 2
    return x
end

To make it efficient, use different names for the temporary variables:

function f(x)
    y = x+1
    z = y/2
    return z
end

You see the source of the inefficiency with @code_warntype.

-erik

4 Likes
18

Infers just fine on 1.7:

julia> function f(x)
           x += 1
           x /= 2
           return x
       end
f (generic function with 1 method)

julia> @code_typed f(1)
CodeInfo(
1 ─ %1 = Base.add_int(x@_2, 1)::Int64
│   %2 = Base.sitofp(Float64, %1)::Float64
│   %3 = Base.div_float(%2, 2.0)::Float64
└──      return %3
) => Float64

To explain: @code_warntype isn’t telling the whole truth here, since the optimizer can actually deal with this when lowering slots to phi nodes.

12 Likes
20

The floating point example feels expected for me (probably not to someone who is newer to writing code) but the rest of it is very interesting! Thank you for the linked post, its helpful as I get more acquainted with the Julia programming language.

1 Like