// F#
type MyType = { owner : obj }

// foldm : ('State -> 'a -> 'State) -> 'State -> seq<'a> -> seq<'a * 'State>
let rec foldm (f: 'State -> 'a -> 'State) s xs =
    if Seq.isEmpty xs
        then Seq.empty
        else let h = Seq.head xs
             seq { yield (h, f s h)
                   yield! foldm f s (Seq.skip 1 xs) }

let limit = 10

let filter self =
    foldm (fun i x -> if (x.owner = self) then 0 else i+1) 0
    >> Seq.takeWhile (fun (_, s) -> s < limit)
    >> Seq.map fst

let comb p max n e | p e = Some (comb p max n)
                   | n < max = Some (comb p max (n+1))
                   | else = None

let filter _ [] = []
    filter comb (x::xs) | res is Some comb = x :: filter comb xs
                        | else = filter comb xs
                        where res = comb x

filter ((==0) << (%2) `comb` 10 <| 0) [1..100]

open core

let comb p max n e | p e = Some (comb p max n)
                   | n < max = Some (comb p max (n+1))
                   | else = None

let apply f c e | c e is Some c' = f e $ c'
                | else = c

let _ = foldl (apply id) ((==0) << (%2) `comb` 5 <| 0) [1..100]

RO>int cOwnSeen = 0;
RO>for(item : items)
RO>{
RO>    if(item.owner != myself || cOwnSeen++ < limit)
RO>    {
RO>        processItem(item);
RO>    }
RO>}
RO>

Process = fun(Element, Acc) ->
             if 
                not Element#item.own andalso Limit >= Acc ->
                   process_element(Element),
                   Acc
                true ->
                   Acc + 1
             end
          end,
lists:foldl(Process, 0, Items).

process_items(Items) ->
  Limit = get_limit(), % получаем откуда-то предел
  do_process_items(Items, Limit, 0).

%% Описание function clauses:
%% 1. элементы закончились. Завершаем
%% 2. количество наших элементов больше лимита. Завершаем
%% 3. следующий элемент в списке наш, мы его пропускаем, увеличиваем счетчик на один
%%    вызываем себя же рекурсивно с остатком списка
%% 4. айтем не наш, мы его процессим
      вызываем сами себя с остатком списка

do_process_items([], _, _) ->
  ok;
do_process_items(_, Limit, Acc) when Acc >= Limit ->
  ok;
do_process_items([#item{own=Own} | Rest], Limit, Acc) when Own =:= true ->
  do_process_items(Rest, Limit, Acc + 1);
do_process_items([#item{} = Element | Rest], Limit, Acc) ->
  do_something(Element),
  do_process_items(Rest, Limit, Acc);

algo2 myself limit processItem xs = evalStateT (mapM_ f xs) 0
  where f x = do cOwnSeen <- get
                 when (owner x /= myself || cOwnSeen < limit) (lift $ processItem x)
                 when (owner x == myself) $ modify (+1)

import std.stdio;

void processItem(Item)(const Item item)
{
writeln(item);
}

void process(Items, Item)(const Items items, const Item myself, const int limit, const int cOwnSeen = 0)
{
if(items.length){
    if(items[0] != myself || cOwnSeen < limit){
        processItem(items[0]);
        }
    process(items[1 .. $], myself, limit, cOwnSeen + 1);
    }    
}

void main()
{
process([1, 2, 1, 3, 1, 4, 1, 5, 6, 1], 1, 3);
}

for counter, item in zip([[limit]]*len(items), items):
    if item.owner != myself or counter[0]:
        processItem(item)
    if item.owner == myself:
        counter[0] -= 1

algo3 myself limit processItem xs = mapM_ processItem $ catMaybes $ snd $ mapAccumL f 0 xs
  where f cOwnSeen x | owner x /= myself = (cOwnSeen, Just x)
                     | cOwnSeen < limit  = (cOwnSeen+1, Just x)
                     | otherwise         = (cOwnSeen, Nothing)

let map _ _ _ _ [] = []
    map p f max n (x::xs) = 
      if p x then
        x :: map p f max n xs
      else if n < max then
        x :: map p f max (n+1) xs
      else
        map p f max n xs

var ownCnt = 0;
var toProcess =
  item
    .Select(i => new {Item = i, Cnt = i.Owner == myself ? ownCnt++ : 0})
    .Where(p => p.Cnt < limit)
    .Select(p => p.Item);

item =>
{
  var cnt = 0;
  if (item.Owner == myself)
    cnt = ownCnt++;
  return new {item, cnt}
}