> let f (i : int ref) a = a + !i;;
val f : i:int ref -> a:int -> int

> let g (i : int ref) b = i := b; b;;
val g : i:int ref -> b:int -> int

> let i = ref 0 in List.map (f i) << List.map (g i) <| [1..10];;
val it : int list = [11; 12; 13; 14; 15; 16; 17; 18; 19; 20]

> let i = ref 0 in List.map (f i << g i) <| [1..10];;
val it : int list = [2; 4; 6; 8; 10; 12; 14; 16; 18; 20]

>> let f (i : int ref) a = a + !i;;
K>val f : i:int ref -> a:int -> int

>> let g (i : int ref) b = i := b; b;;
K>val g : i:int ref -> b:int -> int

>> let i = ref 0 in List.map (f i) << List.map (g i) <| [1..10];;
K>val it : int list = [11; 12; 13; 14; 15; 16; 17; 18; 19; 20]

>> let i = ref 0 in List.map (f i << g i) <| [1..10];;
K>val it : int list = [2; 4; 6; 8; 10; 12; 14; 16; 18; 20]
K>

int i;
auto f(int v) {return v+i++;}
auto g(int v) {return i=v;}
i=0; iota(1, 11).map!g.map!f.writeln;//выводит [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
i=0; iota(1, 11).map!(x=>x.g.f).writeln;//выводит [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

> let f a = printf "f"; a;;
val f : a:'a -> 'a
> let g a = printf "g"; a;;
val g : a:'a -> 'a
> Seq.map f << Seq.map g <| [1..5];;
gfgfgfgfgfval it : seq<int> = seq [1; 2; 3; 4; ...]
> Seq.map (f << g) <| [1..5];;
gfgfgfgfgfval it : seq<int> = seq [1; 2; 3; 4; ...]
(* пока все хорошо *)
> Seq.map f << Seq.toList << Seq.map g <| [1..5];;
gggggfffffval it : seq<int> = seq [1; 2; 3; 4; ...]

t <- over (U.all ((/= 0) . (rem x)) . U.takeWhile ((<= x) . (^2))) primes 
if t then ...

letrec {
    $s$wand_loop1
    $s$wand_loop1 =
      \ sc5 ->
        case >=# sc5 tpl1 of _ {
          False ->
            let { __DEFAULT ~ wild12
            <- indexIntArray# ipv3 (+# rb3 sc5)
            } in
            case <=# (*# wild12 wild12) sc4
            of _ {
              False -> True;
              True ->
                case wild12 of wild14 {
                  __DEFAULT ->
                    case remInt# sc4 wild14
                    of _ {
                      __DEFAULT ->
                        $s$wand_loop1
                          (+# sc5 1);
                      0 -> False
                    };
                  (-1) -> False;
                  0 ->
                    case divZeroError
                    of wild15 {
                    }
                }
            };
          True -> True
        }; } in
  case $s$wand_loop1 0 of _ { ...

Задача заключается в проверке "поддержки иммутабельности" в языке, посредством создания как можно большего числа промежуточных значений в виде иммутабельных структур данных таким образом, чтоб часть из них можно было выкинуть за ненадобностью, а часть нет.

bool WhileAny(string P1, string P2, T)(immutable T[] a, T v, int i=0)
{
    if(i>=a.length||binaryFun!P1(a[i], v)) return false;
    if(binaryFun!P2(a[i], v)) return true;
    return WhileAny!(P1, P2)(a, v, i+1);
}

T Primes(int M, T=immutable IArray!(M, int))(T primes=T.Make()~2~3, int v=5)
{
    if(v>=M) return primes;
    return Primes!M(!primes[].WhileAny!(q{a^^2>b}, q{b%a==0})(v)?primes~v:primes, v+1);
}

import std.stdio, std.algorithm, std.range;

void main() {
    reduce!((p, v)=>p.find!(q{b%a==0||a^^2>b})(v).front()^^2>v?p~=v:p)([2, 3], iota(5, 2^^24)).count.writeln;
}

import Control.Applicative
import Control.Monad
import qualified Data.Vector.Unboxed as U
import qualified Data.Vector.Unboxed.Mutable as M

data Buffer m a = Buffer { len :: !Int, buf :: !(M.MVector m a) }

over f (Buffer c b) = f . U.take c <$> U.unsafeFreeze b

(Buffer c b) <| a | M.length b > c = add b | otherwise = add =<< M.grow b (c*3) where 
    add nb = Buffer (c+1) nb <$ M.write nb c a

buffer l = flip (foldM (<|)) l . Buffer 0 =<< M.new 1000 

main = print . len =<< flip (U.foldM step) (U.takeWhile (<= 2^24) . U.enumFromStepN (5::Int) 2 $ 2^24) 
    =<< buffer [2, 3::Int] where
    step primes x = do 
        t <- over (U.all ((/= 0) . rem x) . U.takeWhile ((<= x) . (^2))) primes 
        if t then primes <| x else pure primes

import qualified Data.List.Stream as S

primes = 2:3:filter isPrime [5,7..] :: [Int]
isPrime x = S.all (/= 0) . S.map (rem x) . S.takeWhile ((<= x) . (^2)) $ primes
main = print . S.length . S.takeWhile (<= 2^24) $ primes

import std.stdio, std.algorithm, std.range;

void main() {
    reduce!((primes, v)=>primes.until!(p=>p^^2>v).all!(p=>v%p)?primes~=v:primes)([3], iota(5, 2^^24, 2)).count.writeln;
}

primes = 2:3:filter' isPrime [5,7..] :: [Int]
isPrime x = all' (/= 0) . map (x `rem`) . takeWhile' ((<= x) . (^2)) $ primes
main = print . length . takeWhile' (<= 2^24) $ primes

step p res x | p x = (x:) | otherwise = res
takeWhile' p = foldr (step p $ const []) []
all' f = foldr (&&) True . map f
filter' p = foldr (step p id) []

immutable struct IArray(int L, T){
    immutable auto opSlice() {return data[0..size];}
    immutable auto opBinary(string op)(in T v) if(op=="~")
    {
        auto d=cast(T*)(data);
        d[size]=v;
        return immutable IArray!(L, T)(data, size+1);
    }
    static auto Make()
    {
        return immutable IArray!(L, T)(cast(immutable T*)(GC.malloc(L*T.sizeof, GC.BlkAttr.NO_MOVE)), 0);
    }
    private T* data;
    private int size;
    invariant() {assert(data!=null, "Неинициализированный объект!"); assert(size<L, "Надо бы побольше пул!");}
};
bool WhileAny(string F1, string F2, T)(immutable T[] a, T v, int i=0)
{
    if(i>=a.length||binaryFun!F1(a[i], v)) return false;
    if(binaryFun!F2(a[i], v)) return true;
    return WhileAny!(F1, F2)(a, v, i+1);
}
T Primes(int M, T=immutable IArray!(M, int))(T primes=T.Make()~2~3, int v=5)
{
    if(v>=M) return primes;
    return Primes!M(!primes[].WhileAny!(q{a^^2>b}, q{b%a==0})(v)?primes~v:primes, v+1);
}
void main()
{
    Primes!(2^^24)[].length.writeln;
}

_>Ну да, это следствие не до конца установившейся терминологии в индустрии. Вот только есть большой вопрос на базе чего она будет устанавливаться: на основе неких академических статей или же по принципу наиболее широкого использования в индустрии...

data [] a = [] | a : [a]

-- и

data Stream a where
  Stream :: Unlifted s => !(s -> Step a s) -> !s -> Stream a

data Step a s = Yield a !s | Skip !s | Done