int foo(string str) => new []{0}.GetHashCode();
foo("hello").Dump();
foo("hello").Dump();

Unlike other functional programming languages, D's pure functions allow modification of the caller state through their mutable parameters.

S>>int foo(string str) => new []{0}.GetHashCode();
S>>foo("hello").Dump();
S>>foo("hello").Dump();
S>>

Function<World, World>

(y, transform) = sin(x);
return (y*y, Combine(transform, transform));

Function<T, T> Combine<T>(Function<T, T> h, Function<T, T> g)
{
  return (T a)=>g(h(a));
}

Function<World, World>

>:type fmap
fmap :: Functor f => (a -> b) -> f a -> f b

>:type fmap sin
fmap sin :: (Functor f, Floating b) => f b -> f b

S>(y, transform) = sin(x);
S>return (y*y, Combine(transform, transform));
S>

S>С одной стороны, всё становится более симметричным; с другой стороны, непонятно, как это работает — в том смысле, кто меня обяжет это делать, вместо того чтобы просто вернуть "нескомпонованный" вариант трансформации. Или вообще просто проложить на него с прибором, и никаких трансформаций не возвращать — обойтись значением .

S>Нутром чую, что это связано с монадами

S>Но как тут уже правильно заметили коллеги, это же всего лишь вопрос каррирования — в ФП функция, которая трансформирует мир, мало чем отличается от функции, которая возвращает трансформацию мира

(Floating a) => IO a -> IO a

S>Да я вообще уже жалею, что ввязался в спор выше уровня моего понимания

Function<World, World>

using static IOModule;

public struct Unit
{
    public static Unit Value => default;
}

public static class IOModule
{
    internal class World { }

    public class IO<a>
    {
        internal readonly Func<World, (a, World)> transform;

        internal IO(Func<World, (a, World)> transform)
        {
            this.transform = transform;
        }
    }

    public static IO<Unit> PutStr(string s) => new IO<Unit>(world =>
    {
        Console.WriteLine(s);
        return (Unit.Value, new World());
    });

    public static IO<string> GetStr() => new IO<string>(world =>
    {
        return (Console.ReadLine(), new World());
    });

    public static IO<a> Return<a>(a x) => new IO<a>(world => (x, world));

    public static IO<b> Bind<a, b>(this IO<a> m, Func<a, IO<b>> f) => new IO<b>(world0 =>
        {
            var (x, world1) = m.transform(world0);
            return f(x).transform(world1);
        });

    public static IO<b> SelectMany<a, b>(this IO<a> m, Func<a, IO<b>> f) => m.Bind(f);

    public static IO<c> SelectMany<a, b, c>(this IO<a> m, Func<a, IO<b>> f, Func<a, b, c> resultSelector) => new IO<c>(world0 =>
        {
            var (x, world1) = m.transform(world0);
            var (y, world2) = f(x).transform(world0);
            return (resultSelector(x, y), world2);
        });

    public static IO<b> Select<a, b>(this IO<a> m, Func<a, b> f) => m.SelectMany(x => Return(f(x)));

    public static void ExecuteAsMain(this IO<Unit> m) => m.transform(new World());
}


class Program
{
    public static IO<double> Sin(double x) =>
        from _ in PutStr(x.ToString())
        select Math.Sin(x);

    public static IO<double> Sin_another(double x) =>
        PutStr(x.ToString()).Bind(_ => Return(Math.Sin(x)));

    public static IO<double> Sin2(double x) =>
        from a in Sin(x)
        from b in Sin(x)
        select a * b;

    public static IO<double> Sin2_another1(double x) =>
        from a in Sin(x)
        select a * a;

    public static IO<double> Sin2_another2(double x) =>
        Sin_another(x).Bind(a => Return(a * a));

    static void Main()
    {
        var main = from _1 in PutStr("What angle?")
                   from s in GetStr()
                   let x = double.Parse(s) * Math.PI / 180.0
                   from result in Sin2(x)
                   from _2 in PutStr($"Result: {result}")
                   select Unit.Value;

        Console.WriteLine("Start execute main funсtion");
        main.ExecuteAsMain();
        Console.ReadKey();
    }
}

import System.IO.Unsafe

putStrLn2 :: String -> IO ()
putStrLn2 (s) = do
    let q = unsafePerformIO $ do { putStrLn " backdoor "; return " 1 "; }
    putStrLn (s ++ q)

putStrLn1 = putStrLn2 "qwerty"

main = do
    putStrLn1
    putStrLn1

qwerty backdoor
1
qwerty 1