# How to a time function exist in functional programming

functional-programming

I've to admit that I don't know much about functional programming. I read about it from here and there, and so came to know that in functional programming, a function returns the same output, for same input, no matter how many times the function is called. It's exactly like a mathematical function which evaluates to the same output for the same value of the input parameters which involves in the function expression.

For example, consider this:

``````f(x,y) = x*x + y; // It is a mathematical function
``````

No matter how many times you use `f(10,4)`, its value will always be `104`. As such, wherever you've written `f(10,4)`, you can replace it with `104`, without altering the value of the whole expression. This property is referred to as referential transparency of an expression.

Conversely, in functional code, the output value of a function depends only on the arguments that are input to the function, so calling a function f twice with the same value for an argument x will produce the same result f(x) both times.

Can a time function (which returns the current time) exist in functional programming?

• If yes, then how can it exist? Does it not violate the principle of functional programming? It particularly violates referential transparency which is one of the property of functional programming (if I correctly understand it).

• Or if no, then how can one know the current time in functional programming?

#### Best Solution

Yes and no.

Different functional programming languages solve them differently.

In Haskell (a very pure one) all this stuff has to happen in something called the I/O Monad - see here.

You can think of it as getting another input (and output) into your function (the world-state) or easier as a place where "impureness" like getting the changing time happens.

Other languages like F# just have some impureness built in and so you can have a function that returns different values for the same input - just like normal imperative languages.

As Jeffrey Burka mentioned in his comment: Here is the nice introduction to the I/O Monad straight from the Haskell wiki.