Do I need to count the newline for Vitsy methods?

Question

Background: Methods in Vitsy are defined by specific indices of lines of code. For example, if I wanted to call the second line of a program, I would call 1m to specify the first index of the methods.

In a recent challenge, I was also asked to count the preceding newline, which sort of made sense, since you needed the newline to even make it a method and the newline was perceived to be the only thing separating it from being a snippet. But then again, how Vitsy does methods in the first place is totally floating; I could put the function 30 or 40 lines down and still call it, but with a different index number.

Should I count this newline, or no?

Answer 1

No, do not count it.

This may seem counter-intuitive at first glance, but it is in fact consistent with how we count bytes.

• We don't count separators in other languages.

  def f(x):return 2*x
  

  is counted as 19 bytes in Python,

  f()(echo $[2*$1])
  

  is counted as 17 bytes in Bash, and

  f(x)=2x
  

  is counted as 7 bytes in Julia.

  All of these function declarations require a newlines before or after them to separate them from the rest of the code.

  Counting

  D+
  

  as 2 bytes is consistent with that way of counting.

• We shouldn't count separators in Vitsy or any other language.

  All four snippets define a function on their own, without any surrounding whitespace. A newline is only required if we want to add additional code to the program (like some code that actually calls the function), but not otherwise.

  Separating the function declaration from the caller is part of calling it, not of declarating it, so it shouldn't contribute to the byte count.

  It would be different if we had to submit two functions to a challenge. For example,

  D+
  3*
  

  should count as 5 bytes, since we need to separate functions somehow.

  This is consistent with how we count bytes for source code that consists of different files (added byte count, plus one extra byte for every file but the first).

• The newline "names the function".

  In Python, we allow

  lambda x:2*x
  

  as well, since it evaluates to a function. To name it (which is required to make the function reusable), we surround it by f= and a newline, none of which contribute to the byte count.

  Prepending a newline to D+ is akin to that, since the function is now callable as <N>m, where N is the 0-based line number.

• It defines a function, even without a newline.

  The program

  +D
  

  consists of a single, "main" function, which is callable as 0m.

  The main function is executed automatically (which may not be what we want at all), but it is still a callable function.

Answer 2

Yes, count it

If you put it down on the 40th line, it would still be preceded by a linefeed that separates it from the previous function.

Imagine you hadn't use linefeeds, but ; as the separator say. It's impossible to introduce a function without writing at least one ; and every single function introduces exactly one ;. I think it's fair to say that the ; (or in your case the linefeed) is part of the function syntax.

Answer 3

No.

The newline is there only to serve as a barrier between the different methods. The newline is not part of the method itself and should not be counted.