Hacker News Reader

Comment by revskill | Hacker News Reader

Curious to know if there's language that differentiate between procedure (function with side-effect) and pure function at the syntax level.

View on HN

Ada does this -- sort of. In the base language procedures can't return anything, and functions must return something. However, either of the two can execute side effects.

The SPARK subset of Ada enforces purity of functions at compile time.

SPARK also allows partial purity, i.e. you can declare that a procedure has side effects, but only in the sense that it uses the wall clock as an input, or only in the sense that it writes to a global variable. You can specify in some detail exactly which side effects are allowed to happen in a procedure.

Nim does this, it has 'proc' and 'func'. They define a `func` as a procedure with no side effects using the macro `{.noSideEffect.}` [1].

[1] https://nim-lang.org/docs/manual.html#procedures-func

Fortran has subroutines and functions. Functions can take multiple arguments and return a single value (however arguments can also be modified). Subroutines can take multiple arguments, which can be inputs, outputs, or both (arguments can be declared inputs or outputs, but it's not required) and don't return a value. And then there's common blocks for sharing variables between subroutines...

And many languages that were influenced by it, from PL/I to CMS-2 (Both of which I used in my first years as a computer programmer)

Common blocks have been outdated for the past >33 years. Modules have been the proper modern safer way of sharing data and procedures since 1990.

That's the whole point of Haskell's separate IO type, and while there are other ways to compose IO values, the usual "do notation" creates a clear visual difference (but not too different) between statements (using <-) and expressions (using =).

Interesting to know. Do you know how the evaluation in IO Monad actually work ?

In theory, Haskell evaluates by graph-reduction, hence its lazy semantics, and then after evaluating a program to an IO value it interprets that, similarly to how e.g. a free monad + interpreter pattern would run. In practice Haskell-98 generally gets lowered into a simple form that can then be executed directly, and the IO monad is represented as effectively the state monad where the state is a marker token that represents the real world. In actual practice real-world Haskell IO with async etc. gets run in various ad-hoc ways that seem to work but aren't necessarily principled.

Among the gcc extensions to C and C++ there are 2 attributes for functions without side effects:

    __attribute__ ((pure))
    __attribute__ ((const))

The 'pure' attribute imposes similar but looser restrictions on a function's definition than the 'const' attribute: 'pure' allows the function to read any non-volatile memory, even if it changes in between successive invocations of the function.

BASIC has SUB (for procedures) vs FUNCTION (for functions).

Yes, Fortran has `pure` and `impure` attributes for functions/subroutines (with and without side-effects). ``` pure recursive function factorial(n) integer, intent(in) :: n ... end ```

I used Borland Turbo Pascal back in the '80s and '90s, and as I recall it had separate keywords and syntax for defining procedures vs. functions.

That was about returning a result or not. The void type made that redundant (in Algol-68).

Reply on news.ycombinator.com