E>def load_header_and_data( stream )
E>    h = load_header( stream )
E>    if stream.respond_to( "seek" )
E>        stream.seek( h.get_length() )
E>    else
E>        stream.read( h.get_length() )
E>    end
E>    load_data( stream )
E>end
E>

E>template< class T >
E>void load_header_and_data( T & stream )
E>{
E>    Header h = load_header( stream );
E>    seek( stream, h.get_length() );
E>    load_data( stream );
E>}
E>

template<typename T> seek(T,int);
template<> seek<File>(File _f, int _bytes);
template<> seek<Soket>(Soket _s, int _bytes);

class File
{
...
void skip(int _bytes){seek(_bytes);}
...
}
class Socket
{
...
void skip(int _bytes){read(_bytes);}
...
}

def load_header_and_data( stream )
    h = load_header( stream )
    if stream.respond_to( "seek" )
        stream.seek( h.get_length() )
    else if stream.respond_to( "move" ) //и такие хаки - еще в 18 местах...
        stream.move( h.get_length() )
    else
        stream.read( h.get_length() )
    end
    load_data( stream )
end

Есть такой тип object. С ним можно вытварять очень много. Есть так же рефлексия с помощью которой хочть черта лысого можно динамически вызвать. Но C# — это статически типизированный язык. Если хотити динамики, то их есть у меня. Есть VB.NET с той самой "утиной типизацией", кстати в 9.0 с ней даже по круче будет. Там придумали "утиные интерфесы" — т.е. описываешь интерфейс как "утиный" и приводишь в рантайме к нему любой объект... если у объектоа методы совпадают, то можно вызвать методы через утиный интерфейс. Что это дает? А тот самый комплит ворд и подсказки среды, плюс еще возможность обнаружить ошибку при инициализации ссылки на интерфейс, а не при вызове 101-вого метода. Далее создали динамические переменные. Когда можно намисать та:

a = "SomeMethodName"
...
b.a(x, y)

за синтаксис не ручвюсь, но смысл думаю понятен.
Но это все из другой оперы. Это все для скриптов. А в нормальных ОО-программах типизация должна быть типзацией, а не утиными историями.

Java/C# не являются ни развитием, ни "осознанием ошибок" C++. Они взяли наихудшую парадигму из языка и возвели ее в степень догмы. А именно — идею наследования. Наследование — это самая большая провокация в индустрии. Ни в каком моделировании наследования не существует и в реальной жизни тоже — ни в электронике, ни в бухгалтерии, ни где бы то ни было еще. Есть одно — генеология. Но это не имеет ни малешего отношения к тому, что называется наследованием в программировании. Все эти многоэтажные иерархии классов только усложняют жизнь, вместо того, чтобы упрощать. И служат они одной единственной цели — раздувать и дальше этот мыльный пузырь и продолжать кормить миллиарды индусов. В результате этой идеи возникла дутая индустрия, не обеспеченная никакими реальными активами. А вся мировая практика говорит о том, что рано или поздно этот пузырь лопнет.

class SmartType<T>
where T: ICountable
{
  public static int q(T param) { return t.Count;}
}

Но это все из другой оперы. Это все для скриптов. А в нормальных ОО-программах типизация должна быть типзацией, а не утиными историями.

Чем больше в системе всяких явно не описанных "соглашений", "умолчаний", "подразумеваний" и т.п., тем меньше у неё шансов добраться до финального релиза. Может быть, я что-то неправильно понял, но вся мощь "утиных историй" проявляется тогда, когда язык программирования не заставляет нас предельно чётко и скрупулёзно описывать понятие "Утка". Один программер что-то там себе подразумевает, а его товарищ может подразумевать что-то чут-чуть другое. Один из них, например, может быть свято уверен, что утки в принципе не умеют летать.

E>

Они взяли наихудшую парадигму из языка и возвели ее в степень догмы. А именно — идею наследования. Наследование — это самая большая провокация в индустрии.

E>
Одобрямс!

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

Пару лет назад, размышляя над этими проблемами, я дошёл до идеи множественной классификации (см. здесь). Лекарство, конечно, слишком сильнодействующее, но я до сих пор не разуверился в том, что рецепт выписан правильно.

...
E>

E>Код load_header_and_data стал понятнее. А хак, хоть и спрятанный, остался.

переместиться_вперед_способом_соответствующим потоку( количество_байтов );

traits< stream >.move_forward(stream, bytes);

E>

Ведь в duck typing нет отношения "is-a", а есть что-то типа "like-a" ("can", "respond_to"). Т.е., наследования нет, а полиморфизм, благодоря динамической типизации, есть.

// Как всегда, на вымышленном языке программирования
class Duck { // Утка
 func УтиУтиУти(Somebody: AHuman);
}

class Alive { // Нечто живое, что может двигаться само
 func Move(Direction: ADirection);
}

class Wild {} // нечто дикое

class Domestic {} // нечто домашнее

func (Duck, Alive)::УтиУтиУти(Somebody: AHuman) { // Сваливаем подальше
   MakeSound("Кря-кря");
};

func (Duck, Wild, Alive)::УтиУтиУти(Somebody: AHuman) { // Сваливаем подальше
  Move(CalcOppositeDirection(GetDirectionTo(AHuman)));
};

func (Duck, Domestic, Alive)::УтиУтиУти(Somebody: AHuman) { // Бежим к человеку. Может, пищу дадут...
  Move(GetDirectionTo(AHuman));
};

// где-то в программе...
var
 Duck1: Duck,  // Просто утка
 Duck2: (Duck, Alive), // Живая утка
 Duck3: (Duck, Wild),  // Дикая утка
 Duck4: (Duck, Wild, Alive), // Дикая живая утка
 Duck5: (Duck, Alive, Domestic); // Домашняя живая утка

Duck1.УтиУтиУти(Me); // Ничего не будет. "Кря-кря" не скажет и никуда не двинется.
Duck2.УтиУтиУти(Me); // Скажет "Кря-кря", но никуда не двинется.
Duck3.УтиУтиУти(Me); // Ничего не будет.
Duck4.УтиУтиУти(Me); // Скажет "Кря-кря" и убежит.
Duck5.УтиУтиУти(Me); // Скажет "Кря-кря" и прибежит.

classify Duck2 as Wild; // Смутировали живую утку Duck2. Сделали её дикой.
Duck2.УтиУтиУти(Me); // Теперь не только крякнет, но ещё и убежит.

IList<Bird> birds = new List<Bird> {penguin, eagle, hedgehog};

List<Bird> l = new List<Bird>();
l.Add(penguin);
l.Add(eagle);
l.Add(hedgehog);
IList<Bird> birds = l;

взять ручку и потянуть

взять ручку и написать "привет"

class Base {
    void f() {...}
    void g() {...}
}
class Derived {
    void f() { super.f(); ...}
}

сlass Base {
  void f() { BaseUtil.f(this); }
    void g() {...}
}
class Derived {
    void f() ( BaseUtil.f(this); ...}
}

void ICollection<int>.Add(int item)
{
    Console.WriteLine(item);
}

Program.cs(8,15): error CS0117: 'A' does not contain a definition for 'Add'
Program.cs(8,15): error CS0117: 'A' does not contain a definition for 'Add'
Program.cs(8,15): error CS0117: 'A' does not contain a definition for 'Add'
Done building project "LINQConsoleApplication1.csproj" -- FAILED.
========== Build: 0 succeeded or up-to-date, 1 failed, 0 skipped ==========

>> int i = 0;
>> double* pd = (double*)&i;
>> *pd = 1.3;
>>

----------------------------------------------------------------
— Дети! Запешите предложине — "В углу сребет мышь.". Все понятно, дети?
— Да, Марья Ивановна... только... ээаа... А кто такой "Вуглускр"?!

def load_header_and_data( stream )
    h = load_header( stream )
    if stream.respond_to( "seek" )
        stream.seek( h.get_length() )
    else
        stream.read( h.get_length() )
    end
    load_data( stream )
end

template <class T, T val>
struct member_wrapper{};

template <class T>
char test_for_seek(const T&, member_wrapper<void (T::*)(size_t), &T::seek>* p = 0);

template <class T>
double test_for_seek(const T&, ...);

template <class T>
struct has_member_seek
{
    static T t;
    static const bool value = (1 == sizeof(test_for_seek(t)));
};

template<bool b>
struct seeker
{
    template <class T>
    static void seek( T & stream, size_t off )
        {
            std::vector< char > buf( off );
            stream.read( &buf[ 0 ], off );
        }
};

template<>
struct seeker<true>
{
    template <class T>
    static void seek( T & stream, size_t off )
        {
            stream.seek( off );
        }
};

template <class T>
void seek( T & stream, size_t off )
{
    seeker< has_member_seek< T >::value >::seek( stream, off );
}

template< class T >
void load_header_and_data( T & stream )
{
    Header h = load_header( stream );
    seek( stream, h.get_length() );
    load_data( stream );
}

FR>Так вроде Duck typing обобщенное программирование в чистом виде, а это довольно старая парадигма

In computer science, generics is a technique that allows one value to take different datatypes (so-called polymorphism) as long as certain contracts such as subtypes and signature are kept. The programming style emphasizing use of this technique is called generic programming.

void LoadHeaderAndData( T stream )
{
    Header h = LoadHeader( stream );
    if( stream.HasMethod( "Seek" ) )
        stream.Seek( h.GetLength() );
    else
        stream.Load( h.GetLength() );
    LoadData( stream );
}

void LoadHeaderAndData( T stream )
{
    Header h = LoadHeader( stream );
    if( has_method(stream, Seek) )
        stream.Seek( h.GetLength() );
    else
        stream.Load( h.GetLength() );
    LoadData( stream );
}

public void LoadHeaderAndData(Stream stream)
{
  Header h = LoadHeader(stream);
  if(stream.CanSeek())
    stream.Seek(h.GetSkipLength());
  else
  {
    byte[] buffer = new byte[h.GetSkipLength()];
    stream.Read(buffer, 0, h.GetSkipLength());
  }
  LoadData(stream);
}

E>>def load_header_and_data( stream )
E>>    h = load_header( stream )
E>>    if stream.respond_to( "seek" )
E>>        stream.seek( h.get_length() )
E>>    else
E>>        stream.read( h.get_length() )
E>>    end
E>>    load_data( stream )
E>>end
E>>

ЗХ>Уникально мерзопакостный вариант

def load_header_and_data( stream )
    h = load_header( stream )
    skip_data( stream, h.get_length() )
    load_data( stream )
end

def skip_data( stream, size )
    if stream.respond_to( "seek" )
        stream.seek( size )
    else
        stream.read( size )
    end
end

ЗХ>template<typename T> seek(T,int);
ЗХ>template<> seek<File>(File _f, int _bytes);
ЗХ>template<> seek<Soket>(Soket _s, int _bytes);
ЗХ>

ЗХ>class File
ЗХ>{
ЗХ>...
ЗХ>void skip(int _bytes){seek(_bytes);}
ЗХ>...
ЗХ>}
ЗХ>class Socket
ЗХ>{
ЗХ>...
ЗХ>void skip(int _bytes){read(_bytes);}
ЗХ>...
ЗХ>}
ЗХ>

E>void LoadHeaderAndData( T stream )
E>{
E>    Header h = LoadHeader( stream );
E>    if( stream.HasMethod( "Seek" ) )
E>        stream.Seek( h.GetLength() );
E>    else
E>        stream.Load( h.GetLength() );
E>    LoadData( stream );
E>}
E>

interface IWorker
{
    void DoWork();
}

class A
{
    // Статически описанное ограничение. Код не скомпилируется если тип
    // используемый как аргумент типа данной функции не будет реализовывать
    // worker
    public static void ConstrainedTest<T>(T value)
        where T: IWorker
    {
        value.DoWork();
    }

    // Динамический запрос интерфейса.
    public static void DynamicTest<T>(T value)
    {
        IWorker worker = value as IWorker;
        if (worker != null)
            worker.DoWork(); // этот код выполнится только если переданный объект реализует IWorker
    }
}

S>public void LoadHeaderAndData(Stream stream)
S>{
S>  Header h = LoadHeader(stream);
S>  if(stream.CanSeek())
S>    stream.Seek(h.GetSkipLength());
S>  else
S>  {
S>    byte[] buffer = new byte[h.GetSkipLength()];
S>    stream.Read(buffer, 0, h.GetSkipLength());
S>  }
S>  LoadData(stream);
S>}
S>

interface ISequentialInputStream : IDisposable
{
    int Read(byte[] buffer, int offset, int count);
    int ReadByte();
}

interface ISequentialOutputStream : IDisposable
{
    void Write(byte[] buffer, int offset, int count);
    void WriteByte(byte value);
}

interface IRandomStream
{
    long Seek(long offset, SeekOrigin origin);
    long Length { get; }
    long Position { get; set; }
}

interface IRandomInputStream : ISequentialInputStream, IRandomStream
{
}

interface IRandomOutputStream : ISequentialOutputStream, IRandomStream
{
    void SetLength(long value);
}

int i = 0;
int j = 2;
std::sort(i, j);

e:\vs\vs2005\vc\include\xutility(1059) : error C2665: 'std::_Debug_range2' : none of the 2 overloads could convert all the argument types
e:\vs\vs2005\vc\include\xutility(1038): could be 'void std::_Debug_range2<_InIt>(_InIt,_InIt,const wchar_t *,unsigned int,std::input_iterator_tag)'
with
[
_InIt=int
]
e:\vs\vs2005\vc\include\xutility(1044): or 'void std::_Debug_range2<_InIt>(_RanIt,_RanIt,const wchar_t *,unsigned int,std::random_access_iterator_tag)'
with
[
_InIt=int,
_RanIt=int
]
while trying to match the argument list '(int, int, const wchar_t *, unsigned int, std::iterator_traits<int>::iterator_category)'
e:\vs\vs2005\vc\include\algorithm(2138) : see reference to function template instantiation 'void std::_Debug_range<_RanIt>(_InIt,_InIt,const wchar_t *,unsigned int)' being compiled
with
[
_RanIt=int,
_InIt=int
]
e:\myprojects\tests\strcpy\strcpy\strcpy.cpp(32) : see reference to function template instantiation 'void std::sort<int>(_RanIt,_RanIt)' being compiled
with
[
_RanIt=int
]

template<class _InIt> inline
    void __CLRCALL_OR_CDECL _Debug_range(_InIt _First, _InIt _Last, const wchar_t *_File, unsigned int _Line)
    {    // test iterator pair for valid range
    _Debug_range2(_First, _Last, _File, _Line, _Iter_cat(_First));
    }

VD>interface ISequentialInputStream : IDisposable
VD>{
VD>    int Read(byte[] buffer, int offset, int count);
VD>    int ReadByte();
VD>}

VD>interface ISequentialOutputStream : IDisposable
VD>{
VD>    void Write(byte[] buffer, int offset, int count);
VD>    void WriteByte(byte value);
VD>}

VD>interface IRandomStream
VD>{
VD>    long Seek(long offset, SeekOrigin origin);
VD>    long Length { get; }
VD>    long Position { get; set; }
VD>}

VD>interface IRandomInputStream : ISequentialInputStream, IRandomStream
VD>{
VD>}

VD>interface IRandomOutputStream : ISequentialOutputStream, IRandomStream
VD>{
VD>    void SetLength(long value);
VD>}
VD>

public static Copy(Stream source, Stream target)
{
  byte[] buffer = new byte[16384];
    int read = 0;
  while((read = source.Read(buffer, 0, buffer.Length)>0)
      target.Write(buffer, 0, read);
}

public static (ISequentialReadStream source, ISequentialWriteStream target){}

public interface IDuck
{
  void Quack();
}

public class DuckImplementation : IDuck
{
  public void Quack()
    {
      System.Console.WriteLine("I'm a normal duck");
    }
}

public class OccasionalDuck // nothing implemented!
{
  public void Quack()
    {
      System.Console.WriteLine("Um, er, I think I occationally appear to be, er, duck ;)"
    }
}

public class DuckUser<Duck> 
where Duck: IDuck
{
  public static MakeQuack(Duck duck)
    {
    duck.Quack();
    }
}

public class DuckDuckUser<T>
where T: duck IDuck
{
  public static MakeQuack(Duck duck)
    {
    duck.Quack();
    }
}

public class NotSoOccasionalDuck: OccasionalDuck, IDuck {}

class Animal { public : virtual void voice() = 0; };

void
get_voice( Animal & beast ) { beast.voice(); }

class Duck : public Animal { public : virtual void voice() { crack(); } ... };
class Dog : public Animal { public : virtual void voice() { gaff(); } ... };

template< class A > void
get_voice( A & beast ) { beast.voice(); }

class Duck { public : void voice() { crack(); } ... };
class Dog { public : void voice() { gaff(); } ... };

def get_voice( beast )
    voice( beast )
end

class Duck; def crack; ... end; end;
class Dog; def gaff; ... end; end;

def voice( beast )
    if beast.respond_to( "crack" )
        beast.crack()
    elfif beast.respond_to( "gaff" )
        beast.gaff()
    end
end

/* Ключевое слово duck_typing вместо template :) */
duck_typing< T, void T::crack() >
void voice( T & beast ) { beast.crack(); }

duck_typing< T, void T::gaff() >
void voice( T & beast ) { beast.gaff(); }

template< class T >
void get_voice( T & beast ) { voice( beast ); }

void get_voice( T beast )
    where T.HasMethod( void Crack() ) || T.HasMethod( void Gaff() )
{
    if( T.HasMethod( void Crack() ) )
        beast.Crack();
    else
        beast.Gaff();
}

E>>Код load_header_and_data стал понятнее. А хак, хоть и спрятанный, остался.

ЗХ>Я предвидел такой ответ

ЗХ>traits< stream >.move_forward(stream, bytes);
ЗХ>

# В старом move_forward были предыдущие специализации.
alias :old_move_forward :move_forward

# А это новая специализация.
def move_forward(stream, bytes)
    if stream.respond_to? :some_unique_seek
        stream.some_unique_seek bytes
    else
        # В противном случае пользуемся старыми специализациями.
        old_move_forward stream, bytes
    end
end

//мое, на C++
if (stream is-a file)
    stream.seek();
else if (stream is-a socket)
    stream.read();
    
//твое, на Ruby
if (stream can seek)
    stream.seek();
else if (stream can read)
    stream.read();

S>А вот с этого — уже понимаю

IRandomInputStream randomStream = stream as IRandomInputStream;
if (randomStream == null)
    проматываем стрим прочитыванием...
else
    randomStream.Seek(...);

S>public static (ISequentialReadStream source, ISequentialWriteStream target){}
S>

Smalltalk считается объектно-ориентированным, а должен был бы ориентированным на обмен сообщениями.

S>>public static (ISequentialReadStream source, ISequentialWriteStream target){}
S>>

class File { public: string read( size_t bytes ); ... };
class RandomGenerator { public: string get( size_t bytes ); ... };
class IOController { public: string peek( size_t bytes ); ... };

string get_n_bytes( File & f, size_t bytes ) { return f.read( bytes ); }
string get_n_bytes( RandomGenerator & g, size_t bytes ) { return g.get( bytes ); }
string get_n_bytes( IOController & c, size_t bytes ) { return c.peek( bytes ); }

class Bytes_Getter { public : virtual string get_n_bytes( size_t bytes ) = 0; ... };

class File_Bytes_Getter { public: virtual string get_n_bytes( size_t bytes ) { return f_.read( bytes ); } ... };
class RandomGenerator_Bytes_Getter { public: virtual string get_n_bytes( size_t bytes ) { return g_.get( bytes ); } ... };
class IOController_Getter { public: virtual string get_n_bytes( size_t bytes ) { return c_.peek( bytes ); } ... };

template< class T > struct Bytes_Getter {};

template<> struct Bytes_Getter< File >{ static string get_n_bytes( File & f, size_t bytes ) { return f.read( bytes ); } };
template<> struct Bytes_Getter< RandomGenerator >{ static string get_n_bytes( RandomGenerator & f, size_t bytes ) { return f.get( bytes ); } };
template<> struct Bytes_Getter< IOController >{ static string get_n_bytes( IOController & f, size_t bytes ) { return f.peek( bytes ); } };

def get_n_bytes( device, bytes )
    if device.respond_to? :read then return device.read bytes
    elsif device.respond_to? :get then return device.get bytes
    elsif device.respond_to? :peek then return device.peek bytes
    else
        fail "unknown beast: #{device.class.name}"
    end
end

VD>int i = 0;
VD>int j = 2;
VD>std::sort(i, j);    
VD>

template< class T >
struct sort_concept_test
    {
        static void constraint( T a )
            {
                ++a;

                T b = a;
                b = a;

                *b = *a;
                bool l = *a < *b;
            }

        sort_concept_test() { void (*p)(T) = constraint; }
    };

template< class T >
void my_sort( T a, T b )
    {
        sort_concept_test< T >();

        std::sort( a, b );
    }

int
main()
    {
        int i, j;
        my_sort( i, j );
    }

sort_2.cpp
sort_2.cpp(13) : error C2100: illegal indirection
sort_2.cpp(7) : while compiling class-template member function 'void sort_concept_test<T>::constraint(T)'
with
[
T=int
]
sort_2.cpp(23) : see reference to class template instantiation 'sort_concept_test<T>' being compiled
with
[
T=int
]
sort_2.cpp(32) : see reference to function template instantiation 'void my_sort<int>(T,T)' being compiled
with
[
T=int
]
sort_2.cpp(13) : error C2100: illegal indirection
sort_2.cpp(14) : error C2100: illegal indirection
sort_2.cpp(14) : error C2100: illegal indirection

std::vector< int > i;
my_sort( i.begin(), i.end() );

VD>Вся история программирования — это борьба с подходами вроде утиной типизации. А ты призывашь обратно в каменный век.

D>>Более того, типизация несколько мешает ОО. Чистое объектное видение мира подразумевает, что любой объект потенциально может отреагировать на любое сообщение. Или другими словами есть только объекты и объекты не различаются ничем, кроме своего поведения. Например, к каждому человеку можно подойти с вопросом "Сколько ты будешь делать?" с параметром ТЗ. На что можно получить в ответ "N дней", "Чего???" или по зубам . Но коллапса с миром не случит в любом случае.

if (object.hasValue()) {
  value = object.getValue();
    // Работаем c value.
}

value = object.getValue();
// Работаем c value. Если value это экземпляр DeafObject, то вся работа с value будет проигнорированна.

if(нечто like-a чемодан) ...

if(нечто can взять-за-ручку) ...

if(нечто can взять-за-ручку && нечто can унести) ...

ЗХ>if(нечто like-a чемодан) ...
ЗХ>

if( нечто.respond_to?( "открыть" ) and
    нечто.respond_to?( "поставить" ) and
    нечто.respond_to?( "взять-за-ручку" ) ) ...

ЗХ>В этом случае от унесения не застрахован любой предмет с ручкой В том числе — дверь, если плохо прикреплена