PA>>outside r = \p -> not (p `inRegion` r)
PA>>x /\ y = \p -> (p `inRegion` x) && (p `inRegion` y)
PA>>x \/ y = \p -> (p `inRegion` x) || (p `inRegion` y)

Т>outside  = not
Т>(/\) = (&&)
Т>(\/) = (||)

inRegion {- x  p -} = ($) -- x $ p = p x
-- поэтому ниже мы его выплавим

outside {- x   p -} = f_gx    (not) {- x   p -}
(/\)    {- x y p -} = f_gx_hx (&&)  {- x y p -}
(\/)    {- x y p -} = f_gx_hx (||)  {- x y p -}

-- где комбинаторы
f_gx    f g x   = f (g x)       -- хорошо известный (.)
f_gx_hx f g h x = f (g x) (h x) -- лень выводить (в базисе Прелюдии будет выглядеть страшно)

К>inRegion {- x  p -} = ($) -- x $ p = p x
К>-- поэтому ниже мы его выплавим

К>outside {- x   p -} = f_gx    (not) {- x   p -}
К>(/\)    {- x y p -} = f_gx_hx (&&)  {- x y p -}
К>(\/)    {- x y p -} = f_gx_hx (||)  {- x y p -}

К>-- где комбинаторы
К>f_gx    f g x   = f (g x)       -- хорошо известный (.)
К>f_gx_hx f g h x = f (g x) (h x) -- лень выводить (в базисе Прелюдии будет выглядеть страшно)
К>

instance Monad ((->) a) where
    return  a = \x-> a
    (>>=) f g  = \x-> g (f x) x

lift2 :: (a -> b -> c) -> (d -> a) -> (d -> b) -> d -> c 
lift2 = liftM2 

lift1 = (.)

outside = lift1 not
(/\) =  lift2 (&&)
(\/) =  lift2 (||)

public FindUsages(line: string, testCase : int, declaration : Location, starter : string) : bool
{
    в тестовом сорце встречаются строки вида 
        mutable acquired = false; // definition {2} acquired     (явное указание объявлений в комментах)
    и строки вида
        acquired = true;  // usage {2}


    выявляем, что ищем
    def name = starter.Substring(starter.IndexOf('}') + 1).Trim();
    def position = line.IndexOf(name);
    def location = Location(declaration.File, declaration.Line, position, declaration.Line, position + name.Length);
    WriteLine($"\nSearching for usages of '$name' (test case: $testCase, location: $location)... ");
    выявили эн вхождений, для которых будем тестировать find references пакета интеграции
    def shouldFindRing = MakeUsage(line, declaration, name, starter) ::
        ScanSources(checkPhrase, testCase).Map((line, _, location, _) => MakeUsage(line, location, name, checkPhrase));
    Write($"\n Should find $(shouldFindRing.Length) usages... ");
    
    для каждого вхождения имитируем клик на нём юзером, и выбор команды find references
    получается список из эн списков, каждый из которых должен быть равен другому
    (действие команды не зависит от того, на каком вхождении кликнул юзер)
    def foundMultiple =
        shouldFindRing.Map(goto =>
        {
            def location = goto.Location;
            def shift = if (name.Length > 1) 1 else 0;
            TheEngine.Project.GetUsages(location.File, location.Line, location.Column + shift).ToList()
        });
    Assert.IsFalse(foundMultiple.IsEmpty); что-то найти мы должны
    здесь собственно, применяем функциональный стиль для проверки равенства этих списков
    def found = foundMultiple.FoldLeft(foundMultiple.Head, (ring, ring') =>
    {
        mutable coincide = false;
        def warning = "Find Usages should produce the same results, disregarding on which usage a user places a cursor";
        try
        {
            coincide = FoldLeft2(ring, ring', true, (a, b, coincideToTheLeft) =>
                if (coincideToTheLeft) a.Location.CompareLines(b.Location) == 0 else false);
        }
        catch
        {
            | _ => coincide = false;
        }
        when (stopAfterFirstFailedTest)
            Assert.IsTrue(coincide, warning);
        ring
    });
    Write($"found $(found.Length) usages, checking for correspondance... ");
    
    а дальше нужно проверить, что найдено действительно то, что должно быть найденно, но это уже другая история...
    def success = FoundUsagesAreRight(testCase, shouldFindRing, found);
    def message = if (success) "ok" else "incorrect!.. saving changes...";
    WriteLine(message);
    success
}

>> inRegion {- x  p -} = ($) -- x $ p = p x
>> -- поэтому ниже мы его выплавим
PA>-- на самом деле inRegion = flip ($)

flip ($) x y = ($) y x = y $ x = x y
flip ($) = id

point `inRegion` region = region point = point $ region
inRegion = ($)

> point `inRegion` region = region point = point $ region
> inRegion = ($)
>

region point = point $ region

Prelude>:t ($)
($) :: (a -> b) -> a -> b

> flip ($) = id
>

key_value_pairs |>
sort (fun (_, x) (_, y) -> compare y x) |>
first 10 |> map fst |> String.concat ";" |> print_endline

    search p l = [mark (p,n) s | s <- l, n <- s p]
                                        -- ^^^^^^^^ здесь s p вернет
                                        -- пустой список, если позиция
                                        -- на доске бесперспективная

G>Вот то же, но со списками, паттерн матчингом и каррингом

def split(s, delim = lambda c : c in " \n\t\f\r\n\v", word = ""):
    if not s: return [word]
    
    if delim(s[0]): return [word] + split(s[1:], delim, "")
        
    return split(s[1:], delim, word + s[0])

Split2(str : string) : array[string]
{
    mutable i = 0; 
    def next () { if (i < str.Length) { def ch = str[i]; i++; ch } else '\0' } 
    def word = Text.StringBuilder();
    def words = Generic.List();
    def addWord() { when (word.Length != 0) { words.Add(word.ToString()); word.Length = 0; } }
    def split(_)
    {
        | '\t' | '\n' | '\'' | ' ' => addWord();          split(next())
        | '\0'                     => addWord();
        | x                        => _ = word.Append(x); split(next())
    }
    
    split(next());
    words.ToArray();
}

FR>def split(s, delim = lambda c : c in " \n\t\f\r\n\v", word = ""):
FR>    if not s: return [word]
    
FR>    if delim(s[0]): return [word] + split(s[1:], delim, "")
        
FR>    return split(s[1:], delim, word + s[0])
FR>

def split2(s, delim = lambda c : c in " \n\t\f\r\n\v"):
    def _(sum, c):
        if delim(c): return sum + [""]
        return sum[:-1] + [sum[-1] + c]
        
    return reduce(_, s, [""])

widget.on_mouse_down {|button, x, y| ...} #функция-обработчик всех сообщений mouse_down
widget.on_mouse_down(LEFT_BUTTON) {|x, y| ...} #сюда паттерн-матчатся только left_mouse_down

#и т.п.
widget.on_key_press{|key, shifts| ...}
widget.on_key_press(Key::A){|shifts| ...}
widget.on_key_press(Key::A, Key::SHIFT){ ...}
widget.on_key_press(nil, Key::SHIFT){|key| ...}