Are objects in Haskell valid if there is no input?

Question

We allow both programs and functions. Some challenges, mostly kolmogorov-complexity challenges, do not require input. This means that for some challenges you can write a function that takes no input. In many languages this is rather straight forward. For example if a challenge asked you to output 26 python function to do these it would look like this:

lambda:26

In Haskell this is a bit stranger. There are two arguments to be had:

• Haskell does not have functions that take no inputs so you must write a complete program. You should write:

  main=print 26
  

• Everything in Haskell is a function, input-less functions are just objects. You can just write:

  26
  

  and that's a function that takes no args and returns 26.

I don't very much like either of these arguments. The first seems to me to be treating Haskell as if it were Python while the second seems to be arguing that snippets are ok, which I certainly don't believe.

What should be allowed in Haskell for challenges that don't allow input?

Before anyone says, "Why does this even matter? A challenge this simple would be closed anyway." Often these types of challenges have further stipulations for example this answer-chaining question requires each entry only to output a number, but has source restrictions on each answer.

Answer 1

As stated in the comments I have been undecided about this matter, but thinking a bit lead to the following argument in favour of the second option:

In Haskell 26 is a valid anonymous function which takes no argument

Haskell's laziness makes each object behave like a function which only returns its value when called, even though the call needs no arguments and happens implicit.

Consider the declaration x=mod 1 0. Division by 0 causes an exception, but only when the value is actually computed. Because of the lazy evaluation, the declaration causes no exception, just like a function declaration x=lambda:1/0 in Python does not cause an error.

Only if we force x to yield its value, e.g. by writing print x, the exception is thrown, just like print(x()) in Python throws an error. Thus x can be considered to be a function.

However, as the site rules allow anonymous functions, in the above case mod 1 0 then is an anonymous function, as is 26 or [1,2,3].

---

I do see the problem that this is essentially allowing snippets in Haskell, but this is different than allowing snippets in general. Rather the proposal would be to recognize lazy evaluation as implicit function evaluation.

This would solve the problem for Haskell and potential other languages that support lazy evaluation, though it would still persist e.g. in Standard ML which also has no dedicated syntax for functions taking no arguments, but also no strong laziness concept.

Answer 2

If 26 evaluates to a function which takes no arguments and returns the number 26, then it is a valid function submission.