Haskell vs Backus

None of these functional programmers, including the Haskell people, seem to have understood Backus's paper. They don't even understand the words in front of them. They think ``no variables'' means no assignment. He very clearly meant no variables as in no variable definitions, only function definitions.

Haskell would not qualify as functional programming by Backus's definition because it has variable definitions. That's the first clue that something is wrong. Either Backus's idea is such a failure that even ``pure functional programmers'' don't want to use it or it's some kind of scam. Backus founded a religion but his own followers don't follow its teachings.

He very clearly meant no variables as in no variable definitions, only function definitions.

How would functions be able to compute anything without variables?

>>2
function sq(){return arguments[0]*arguments[1]}
sq(9,11)

>>3

arguments aren't variables

>>4
Arguments aren' t variables, but formal parameters are.

>>2,4
Given a suitable set of primitive functions - whose bodies are black boxes, and whose signatures are assumed to be known, so the programmer never sees either variable or argument definitions - the rest can be built with sufficiently creative applications of function composition.

That said, a subset of the primitives Backus proposed included functions of the form fi, which return the ith element of their argument vectors, which Dijkstra pointed out is just a clumsier way of naming arguments.

Here is a function that has no named variables or indexes to arguments array:
function argcount(){return arguments.length}
argcount(11,22,33)//returns 3

HURRRR DURRR IM A FUCKING RETORD!!!

>>7
Anonymous variables are still variables.

>>8
EPIC FIAL

Variable is a function with no arguments!

>>10
No, a variable is just a way of identifying a value that is stored somewhere. Even in >>7's example, which technically uses "anonymous" variables, the arguments still have an identity insofar as being a list passed to the function.

``A function with no arguments" is essentially the same thing as a constant, not a variable. The maximum number of unique values of a function is equal to the maximum possible unique combinations of arguments, and supposing (just for this example) that all arguments are boolean, a unary function has 2 possible values, a binary function has 4 possible values, and a ternary function has 8. Regardless of the range of argument types, a nullary function only has one possible value, because the ONLY possible combination of arguments is "no arguments". Which means, if a nullary function actually is a function, then it just stores a single value, making it equivalent to a constant.

There is no meaningful difference between

function pi() { return 3.14; }

and

const pi = 3.14;

>>11
A constant is a variable whose value cannot change at run time!

>>12
Which means a constant has the same functionality as a constant function. Any decent compiler will treat them the same in any case.

>>11
what about functions that utilize globals?

>>14
what about functions that utilize MY ANUS

>>14

There is no mutability in the haskell world!

>>11
A variable is just a way of identifying an immutable value that is stored somewhere.
Variables that change are not variables, they're assignables.

>>14
Those ``functions" are not functionally pure, and therefore are not truly functions in the mathematical sense.

>>15
See above, unless your anus is passed explicitly as an argument to the function.

>>18
I don't think mathematics really cares where it's inputs come from or where outputs are stored, that's why it's so universal

>>19
Math requires inputs to be on the stack.