LCR>>Много синтаксического оверхеда. Это не компактный код. Это просто утоптанный код

E>Может вот это подойдет

Автор: Lazy Cjow Rhrr
Дата: 06.12.05

?

...ваш первый опыт чтения статьи по математике может быть пугающим: чтение одной страницы занимает полчаса. И все же я уверен, что проблема не в нотации, как может показаться на первый взгляд. Статью по математике трудно читать, потому что сложны сами идеи.

basicmatrix[elementaryrow][elementarycolumn] = basicmatrix[elementaryrow][elementarycolumn] + 1;

m[i ][j] ++;

sort([Pivot | T]) ->
    sort([ X || X <- T, X < Pivot]) ++
    [Pivot] ++
    sort([ X || X <- T, X >= Pivot]);
sort([]) -> [].

qsort( a, lo, hi ) int a[], hi, lo;
{
  int h, l, p, t;
  if (lo < hi) {
    l = lo;
    h = hi;
    p = a[hi];
    do {
      while ((l < h) && (a[l] <= p)) 
          l = l+1;
      while ((h > l) && (a[h] >= p))
          h = h-1;
      if (l < h) {
          t = a[l];
          a[l] = a[h];
          a[h] = t;
      }
    } while (l < h);
    t = a[l];
    a[l] = a[hi];
    a[hi] = t;
    qsort( a, lo, l-1 );
    qsort( a, l+1, hi );
  }
}

Сделаем выводы и сформулируем некоторые отличия от общепринятых трактовок (отличия, впрочем, небольшие):

Всегда ошибетесь с контекстом, если будете класс "выводить из подсистемы".

2. Когда Ваш оператор if привязан к объекту, есть вероятность, что данную ошибку Вы совершили.

Но в какой-то момент надо сделать шаг вперед. Есть более удобные, чем "тип", термины: "однородность", "контекстность". Мы будем говорить, что сущности однородны, если они принадлежат одному контексту.

Так, во всех перечисленных выше разных примерах допущена одна и та же ошибка, и в этом смысле все эти разные примеры — однородны.

А если мы заведем группу "Разный неструктурированный мусор", то все помещенное в эту группу будем считать однородным с точки зрения данного контекста.

"Сущности, принадлежащие типу "Разнородные"

4. Значит, можно трактовать класс не столько как тип и не столько как общий случай нашего частного объекта, сколько как один из контекстов для функций, частный случай группировки функций — место, где функции ("методы") лежат "пачкой".

Эта трактовка совсем уж нарушает общепринятую ООП-традицию, но и не отрицает ее – просто сводит к частному случаю

Мысль 5: В идеале созданный мной контекст должен быть таким, чтобы инкапсулированные в нем функции (методы) ничего не знали о том, кого они обслуживают. "Кого надо, того и обслужат". Обслужат любую ("any") сущность.

#!/usr/bin/perl

$;="@{'`|;{'^'!.|-'}";$.++;$.++;$.++;$_="(.)?";/((?{$_.=$_}).)+$/;@_='~!@#$%^&*(
)_+`-=[]\\{}|;\':",./<>? '=~/$_/;@_ 
_=$;=~/$_/;$_="(.)*?";/((?{$_.=$_}).)+$/;$Z-=
$Z;"$.$."-$Z;/((?{$_ _[$z]&&!("${_[$x]}"^"${_[$y]}"^"${_ 
_[$z]}"^"$Z")&&($a.=$_[$x
],$b.=$_[$y],$z++);$x++;$y+=!($x%="$.$.");$y%="$.$.";}).)+/;$_="^"^"^";$_ 
_=".>.\
'$_ _ _$b')".".('!\@/\"'^'}.')".']}`';

<zenspider> singletons are almost always a sign of bad design.
<suryam> but i need it in my design... [...]
<zenspider> "need" is almost always a sign of bad thought.

C>#!/usr/bin/perl

C>$;="@{'`|;{'^'!.|-'}";$.++;$.++;$.++;$_="(.)?";/((?{$_.=$_}).)+$/;@_='~!@#$%^&*(
C>)_+`-=[]\\{}|;\':",./<>? '=~/$_/;@_ 
C>_=$;=~/$_/;$_="(.)*?";/((?{$_.=$_}).)+$/;$Z-=
C>$Z;"$.$."-$Z;/((?{$_ _[$z]&&!("${_[$x]}"^"${_[$y]}"^"${_ 
C>_[$z]}"^"$Z")&&($a.=$_[$x
C>],$b.=$_[$y],$z++);$x++;$y+=!($x%="$.$.");$y%="$.$.";}).)+/;$_="^"^"^";$_ 
C>_=".>.\
C>'$_ _ _$b')".".('!\@/\"'^'}.')".']}`';

basicmatrix[elementaryrow][elementarycolumn] ++;

m[i ][j] ++;

E>>>basicmatrix[elementaryrow][elementarycolumn] ++; 
E>>>//vs
E>>>m[ i ][ j ] ++;
LCR>>

min([H|T]) -> min(T, H).

min([H|T], Min) when H < Min -> min(T, H);
min([_|T], Min)              -> min(T, Min);
min([],    Min)              -> Min.

minimum([Head|Tail]) -> minimum(Tail, Head).

minimum([Head|Tail], Minimum) when Head < Minimum -> minimum(Tail, Head);
minimum([_|Tail],    Minimum)                     -> minimum(Tail, Minimum);
minimum([],          Minimum)                     -> Minimum.

int iOldX;
int iOldY;
int cx;
int cy;
//...
int iNexX = iOldX + cx;
int iNewY = iOldY + cy;

CPoint pt;
CSize sz;
//...
CPoint pt1 = pt + sz;

не_помню_названия_типа *func[]=
{
    &DrawFunc1,
    &DrawFunc2,
    &DrawFunc3,
    &DrawFunc4,
    &DrawFunc4,
    &DrawFunc5,
    &DrawFunc6,
    &DrawFunc7
};

char* doSmth(char * pszBuff, DWORD dwSize, char* find, char in, char out) {
    // Ищем строку
    // Ищем открывающий символ
    // Ищем закрывающий символ
    // Сохраняем значение

    return pszTemp;
}

C>Щас на K (начал изучать — классный язык!) попробую что-нибудь написать

divmod=: <.@% , |~

anag=: (4 : 0)^:(1: < #@])
  'q n'=. x. divmod !<:#y.
  (q{y.) , n anag (q{.y.) , (>:q)}.y.
)

  999999 anag '0123456789'
2783915460

ANS>Естественно, нужно учитывать насколько сильно ограничивакт ЯП Начиная с такого:

doDmth("Одни данные"):
doDmth("Другие данные"):
doDmth("Третьи данные"):
//...
doDmth("Энные данные"):

FR>Это на законы никак ни тянет, так просто пожелания

As an illustration, consider the class Morph, which is the root of the GUI framework in Squeak. Morphs have a hierarchic structure: a Morph contains an instance variable named submorphs, which is a (possibly empty) collection of Morph objects. Morph also implements a few methods such as addMorph:, removeMorph:, and moveMorphToFront:, which add and remove submorphs and change how they are layered. /.../
With class-based encapsulation mechanism, the only way to ensure this is to make the reference to the submorphs secret and never pass it out of the parent morph. Unfortunately, this conflicts (выделение моё) with the need of some of Morph’s clients to use the protocol provided in Collection to enumerate the submorphs.

We seek a mechanism that is expressive, simple, and appropriate for dynamic languages.

LCR>sort([Pivot | T]) ->
LCR>    sort([ X || X <- T, X < Pivot]) ++
LCR>    [Pivot] ++
LCR>    sort([ X || X <- T, X >= Pivot]);
LCR>sort([]) -> [].
LCR>

LCR>qsort( a, lo, hi ) int a[], hi, lo;
LCR>{
LCR>  int h, l, p, t;
LCR>  if (lo < hi) {
LCR>    l = lo;
LCR>    h = hi;
LCR>    p = a[hi];
LCR>    do {
LCR>      while ((l < h) && (a[l] <= p)) 
LCR>          l = l+1;
LCR>      while ((h > l) && (a[h] >= p))
LCR>          h = h-1;
LCR>      if (l < h) {
LCR>          t = a[l];
LCR>          a[l] = a[h];
LCR>          a[h] = t;
LCR>      }
LCR>    } while (l < h);
LCR>    t = a[l];
LCR>    a[l] = a[hi];
LCR>    a[hi] = t;
LCR>    qsort( a, lo, l-1 );
LCR>    qsort( a, l+1, hi );
LCR>  }
LCR>}
LCR>

List Sort(List list)
{
    Elem pivot = GetFirst(list);
    return Concat(GetGreater(list, pivot), pivot, GetSmallerOrEq(list, pivot));
}

    ord =: /:@:/:
    ord 6 4 5 10
2 0 1 3

std::string res;
for(std::string::const_iterator f=str.begin();f!=str.end();++f)
{
    if (str.compare("aa",f,2)==0)
    {
        res+="bb";
        f+=2;
    }
    else
        res+=*f;
}