getChar :: IO Char

The return function admits an ordinary value such as a boolean to the realm of I/O actions. What about the other direction? Can we invoke some I/O actions within an ordinary expression? For example, how can we say x + print y in an expression so that y is printed out as the expression evaluates? The answer is that we can't! It is not possible to sneak into the imperative universe while in the midst of purely functional code. Any value `infected' by the imperative world must be tagged as such. A function such as

f :: Int -> Int -> Int

absolutely cannot do any I/O since IO does not appear in the returned type.

pure <$> foobar

D>>pure <$> foobar
D>>

> {foobar::IO a; foobar = undefined}
> :t const foobar
const foobar :: b -> IO a
> :t const <$> foobar
const <$> foobar :: IO (b -> a)

fold2 :: Maybe a -> Maybe b -> (a -> b -> c) -> Maybe c
fold2 mba mbb f = do
  a <- mba
  b <- mbb
  return $ f a b

--test it
λ> fold2 (Just 10) (Just 20) (+)
Just 30

λ> mapM print [1,2,3]
1
2
3
[(),(),()]

λ> mapM Just [1,2,3]
Just [1,2,3]

type Ops = Free OpsF

foo :: Ops (Map Key Val)
foo = do
  let k1 = "foo1"
  let k2 = "foo2"
  put k1 "value1"
  put k2 "value2"
  transact $ do
    (vt1, vt2) <- transact $ do
      v1 <- get k1
      v2 <- get k2
      return (v1, v2)
    transact $ do
      put k1 vt2
      put k2 vt1
  -- get one by one, not in transaction
  vn1 <- get k1
  vn2 <- get k2
  return $
    insert k1 vn1 $
    insert k2 vn2 empty

Unfortunately the interaction between generic code and pure (as well as const and immutable) is rather poor. There have been several proposals to fix this, but none have been accepted yet.
\std.algorithm is written to be as generic as possible, so it can't require that its lambda functions and the ranges it accepts be pure. Furthermore, the type system features that were added in D2 are generally the most buggy features in the language, because more basic things have been prioritized ahead of fixing the relevant issues. Right now, pure is basically not usable except for trivial cases like std.math.

int f(int i) pure {
    return i*i;
}
int h(int i) {
    writeln("Bad");
    return i*i;
}
int g(int function(int) pure func) pure {
    return func(10);
}
void main(string[ ] args)
{
   writeln(g(&f)); //no prob
   writeln(g(&h)); //???
}

import std.stdio, std.algorithm;

void myDirtyFun() { // используем map в грязной ф-ии
    auto xs = [1,2,3].map!((x) { write(x, " "); return x*2; }); 
    writeln(xs.sum);    
}

int myPureFun() pure { // используем map в чистой ф-ии
    auto xs = [1,2,3].map!(x => x*2);
    //write("hi"); // если раскомментировать, компилятор ругнется:
    // Error: pure function 'main.myPureFun' cannot call impure function 'std.stdio.write!string.write'
    return xs.sum;
}

void main(string[] argv) {
    myDirtyFun(); // 1 2 3 12
    writeln( myPureFun() ); // 12
}

int f(int i) pure {
    return i*i;
}
int h(int i) {
    writeln("Bad");
    return i*i;
}

int g(alias func)() { // автоматически чистая или грязная в зависимости от func
    return func(10);
}

int makeSureWeReStillPure() pure {
    return g!f + 1;
}

void main(string[ ] args)
{
    writeln(g!f); 
    writeln(g!h); 
    writeln(makeSureWeReStillPure());
}

100
Bad
100
101

() pure {
  x = xs.map!f.filter!g.reduce!h;  // можно, пока все чистое
  y = x + f(42); 
  // writeln("io"); // а вот этого компилятор не даст!
} ();

auto f(int x) {return x*2;}

writeln(__traits(getFunctionAttributes, f)); //pure нет
writeln(__traits(getFunctionAttributes, function (int x)=>x*2)); //pure есть

static assert ([__traits(getFunctionAttributes, my_func)[]].canFind("pure"), "Impure!");

writeln(__traits(getFunctionAttributes, function (int x)=>x*2)); //pure есть

int g(alias func)() 
if (isCallable!func && is(ReturnType!func==int) && Parameters!func.length==1 && is(Parameters!func[0]==int)) { 
    return func(10);
}