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>

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

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

traits< stream >.move_forward(stream, 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