1. D(DMD) — 0.645 сек
   
2. D(GDC) — 0.653 сек
   
3. С#/Nemerle — 0.870 сек
   
4. Boo — 1.003 сек (*)
   
5. Python+Psyco — 1.451 сек
   
6. Python — 2.182 сек
   
7. Java/Scala — 3.470 сек
   
8. C++(GCC),boost,list,is_space — 10.045 сек (**)
   
9. C++(MS),boost,list,is_space — 12.708 сек (**)

1. Nemerle-Tokenizer — 0.738 сек
   
2. Nemerle-withLists — 0.896 сек
   
3. Java-Bicycle — 1.369 сек
   
4. Java-Tokenizer — 2.119 сек
   
5. C++(MS),Noname2,list,functor,ref — 2.463 сек (*)
   
6. Scala-Tokenizer — 2.642 сек
   
7. Scala-withLists — 2.785 сек
   
8. C++(GCC),VK,list,functor,val — 3.896 сек (*)

import System;
import System.Diagnostics;

stopwatch = Stopwatch();
stopwatch.Start();

res = 0;

for i in range(1000000):
    res += "123 345 asdf 23453 asdfas".Split().Length;
  
stopwatch.Stop();
      
Console.WriteLine("Boo: res is ${res}, ${stopwatch.Elapsed} elapsed");

import java.io.*;
import java.util.*;

class splitjava {
    public static void main(String[] args) {
        long start = System.nanoTime();
        
        int res = 0;
        
        for(int i = 0;i < 1000000;i++)
          res += "123 345 asdf 23453 asdfas".split(" ").length;
          
        long stop = System.nanoTime();
        System.out.println("Java-StdLib: res = "  + res + ", " + ((double)(stop - start) / 1.0e6) + " ms elapsed");
    }
}

import java.io;
import java.util;

object splitscala {
    def main(args : Array[String]) = {
        val start = System.nanoTime();
        
        var res = 0;
        
        for (val i <- Iterator.range(0, 1000000)) 
          res = res + "123 345 asdf 23453 asdfas".split(" ").length;
          
        val stop = System.nanoTime();
        System.out.println("Scala-StdLib: res = "  + res + ", " + ((stop - start) / 1.0e6) + " ms elapsed");
    }
}

using System.Console;
using System.Diagnostics;

module Parse
{
  public SplitToList(this str : string) : list[string]
  {
    def loop(start, i, lst)
    {
      if (i < str.Length)
        match (str[i])
        {
          | ' '  => str.Substring(start, i - start) :: loop(i + 1, i + 1, lst)
          | _ => loop(start, i + 1, lst)
        }
      else if (start == i) lst
      else                 [str.Substring(start, i - start)];
    }

    loop(0, 0, []);
  }

  public Tokenize(this str : string) : System.Collections.Generic.IEnumerable[string]
  {
    def loop(start, i)
    {
      if (i < str.Length)
        match (str[i])
        {
          | ' ' =>
            yield str.Substring(start, i - start);
            loop(i + 1, i + 1)

          | _ => loop(start, i + 1)
        }
      else if (start != i) yield str.Substring(start, i - start)
      else                 ()
    }

    loop(0, 0);
  }
}

////////////////////////// Далее идут тесты /////////////////////////////////

WriteLine(Parse.SplitToList("123 345 asdf 23453 asdfas"));

def stopwatch = Stopwatch();

/////////////////////////////////////////////////////////////////////////////
// Тестируем сплит написанный что называется в стиле "мама не горюй" (с динамическими списками).

stopwatch.Start();

mutable count = 0;
repeat(1000000)
  count += Parse.SplitToList("123 345 asdf 23453 asdfas").Length;
  
stopwatch.Stop();

WriteLine($"Nemerle-withLists: res=$count, $(stopwatch.Elapsed) elapsed");


/////////////////////////////////////////////////////////////////////////////
// Тестируем токенайзер.

stopwatch.Reset();
stopwatch.Start();

count = 0;
repeat(1000000)
  foreach (_ in Parse.Tokenize("123 345 asdf 23453 asdfas"))
    count++;

stopwatch.Stop();

WriteLine($"Nemerle-Tokenizer: res=$count, $(stopwatch.Elapsed) elapsed");

import java.io.*;
import java.util.*;

class SplitNoname2 {
    private static int testTokenizer() {
        int answer = 0;
        for (int i = 0; i < 1000000; i++) {
            final List<String> list = new ArrayList<String>();
            final String text = "123 345 asdf 23453 asdfas".intern();
            for (final StringTokenizer strtok = new StringTokenizer(text);
                strtok.hasMoreTokens(); list.add(strtok.nextToken())) ;
            answer += list.size();
        }
        return answer;
    }

    private static int testNoname2() throws UnsupportedEncodingException {
        int answer = 0;
        final byte space = " ".getBytes("windows-1251")[0];
        
        for (int i = 0; i < 1000000; i++) {
            final List<String> array = new ArrayList<String>();
            final String text = "123 345 asdf 23453 asdfas".intern();//.getBytes("windows-1251");
            final int clen = text.length();
            
            for (int c = 0, x = 0; c < clen; c++) {
                if (text.charAt(c) == space) {
                    array.add( text.substring(x, c));
                    x = c + 1;
                } else if (c == clen - 1 && clen - x > 1) {
                    array.add( text.substring(x, clen) );
                }
            }
            answer += array.size();
        }

        return answer;
    }

    public static void main(String [] args) throws UnsupportedEncodingException {
        long start = System.nanoTime();
        int res = testTokenizer();
        long stop = System.nanoTime();
        System.out.println("Java-Tokenizer: res = "  + res + ", " + ((double)(stop - start) / 1.0e6) + " ms elapsed");
        
        start = System.nanoTime();
        res = testNoname2();
        stop = System.nanoTime();
        System.out.println("Java-Noname2: res = "  + res + ", " + ((double)(stop - start) / 1.0e6) + " ms elapsed");
    }
}

import java.io;
import java.util;
import System.out._

object SplitVlad
{
  def SplitToList(str : String) : List[String] = {
    def loop(start : Int, i : Int, lst : List[String] ) : List[String] = {
      if(i < str.length)
        str(i) match
        {
          case ' '  => str.substring(start, i) :: loop(i + 1, i + 1, lst);
          case _    => loop(start, i + 1, lst);
        }
      else if (start == i) lst;
      else                 List(str.substring(start, i));
    };

    loop(0, 0, Nil);
  }
  
  def Tokenize(str : String) = new Iterator[String]{
    var start : Int = 0
    var i : Int = 0
    var r : String = "";
 
    def hasNext : boolean = 
    {
      if (i < str.length)
          str(i) match
          {
            case ' ' =>
              r = str.substring(start, i);
              i = i + 1; start = i;
              true;
            case _ => 
              i = i + 1;
              hasNext;
          }
      else if (start != i) { r = str.substring(start, i); start = i; true }
      else                 false
    }
    
    def next = r;
  }
 
  def main(args : Array[String]) = {
  
     // check
     print("SplitToList: [");
     for(val s <- SplitToList("123 345 asdf 23453 asdfas") )
        print(s + ",");
     print("]\n");     
     
     print("Tokenizer: [");
     for(val s <- Tokenize("123 345 asdf 23453 asdfas") )
        print(s + ",");
     print("]\n");     
  
    var start = System.nanoTime();
    
    var res = 0;
    
    for (val i <- Iterator.range(0, 1000000)) 
      res = res + SplitToList("123 345 asdf 23453 asdfas").length;
      
    var stop = System.nanoTime();
    println("Scala-SplitToList: res = "  + res + ", " + ((stop - start) / 1.0e6) + " ms elapsed");
    
    start = System.nanoTime();
    
    res = 0;
    
    for (val i <- Iterator.range(0, 1000000)) 
      for(val s <- Tokenize("123 345 asdf 23453 asdfas") )
        res = res + 1;
      
    stop = System.nanoTime();
    println("Scala-Tokenizer: res = "  + res + ", " + ((stop - start) / 1.0e6) + " ms elapsed"); 
  }
}

#include <list>
#include <vector>
#include <string>
#include <iostream>

#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>

#include <windows.h> // for GetTickCount

using namespace std;
using namespace boost::algorithm;

class SplitNoname2
{
public:
  template <class C, class P>
  inline static void SplitVal(C& tokens, const string& str, P is_delimiter)
  {
      size_t inpSize = str.size();
      
      for (size_t c = 0, x = 0; c < inpSize; ++c ) {
          if( is_delimiter(str[c]) ) {
              tokens.push_back( str.substr(x,c-x) );
              x = c + 1;
          } else if (c == inpSize - 1 && inpSize - x > 1) {
              tokens.push_back( str.substr(x,inpSize-x) );
          }
      }
  }
  template <class C, class P>
  inline static void SplitRef(C& tokens, const string& str, const P& is_delimiter)
  {
      size_t inpSize = str.size();
      
      for (size_t c = 0, x = 0; c < inpSize; ++c ) {
          if( is_delimiter(str[c]) ) {
              tokens.push_back( str.substr(x,c-x) );
              x = c + 1;
          } else if (c == inpSize - 1 && inpSize - x > 1) {
              tokens.push_back( str.substr(x,inpSize-x) );
          }
      }
  }
};

class SplitVK
{
public:
  template <class C, class P>
  inline static void SplitVal(C& tokens, const string& str, P is_delimiter)
  {
      typename string::const_iterator it = str.begin(), token_start = it, end = str.end();
      for(; it != end; ++it)
      {
          if (is_delimiter(*it))
          {
              if (token_start != it)
                  tokens.push_back(string(token_start, it));
              ++(token_start = it);
          }
      }
      if (token_start != it)
          tokens.push_back(string(token_start, it));
  }
  template <class C, class P>
  inline static void SplitRef(C& tokens, const string& str, const P& is_delimiter)
  {
      typename string::const_iterator it = str.begin(), token_start = it, end = str.end();
      for(; it != end; ++it)
      {
          if (is_delimiter(*it))
          {
              if (token_start != it)
                  tokens.push_back(string(token_start, it));
              ++(token_start = it);
          }
      }
      if (token_start != it)
          tokens.push_back(string(token_start, it));
  }
};

class MyIsSpace
{
public:
  inline bool operator()(char c) const { return c == ' '; } 
};

inline bool myIsSpace(char c){ return c == ' '; }

template<class C, class Pred>
inline void TestBoost( const string& testName, Pred pred )
{
  DWORD start = GetTickCount();
  
  string str = "123 345 asdf 23453 asdfas";

  size_t res = 0;
  for(int i = 0; i < 1000000; i++)
  {
    C tokens; 
    split(tokens, str, pred);
    res += tokens.size();
  }

  DWORD stop = GetTickCount();

  cout << "C++,boost," << testName << ": res is " << res << ',' << stop - start << " ms elapsed\n";
}

template<class Splitter, class C, class Pred>
inline void Test( const string& testName, Pred pred )
{
  DWORD start = GetTickCount();
  
  const string str = "123 345 asdf 23453 asdfas";

  size_t res = 0;
  for(int i = 0; i < 1000000; i++)
  {
    C tokens; 
    Splitter::SplitVal(tokens, str, pred );
    res += tokens.size();
  }

  DWORD stop = GetTickCount();

  cout << "C++," << testName << ",val: res is " << res << ',' << stop - start << " ms elapsed\n";
  
  start = GetTickCount();

  res = 0;
  for(int i = 0; i < 1000000; i++)
  {
    C tokens; 
    Splitter::SplitRef(tokens, str, pred );
    res += tokens.size();
  }

  stop = GetTickCount();

  cout << "C++," << testName << ",ref: res is " << res << ',' << stop - start << " ms elapsed\n";
}

int main()
{
  
  TestBoost< vector<string> >("vector,is_any_of", is_any_of(" ") );
  TestBoost< list<string> >("list,is_any_of", is_any_of(" ") );
  
  TestBoost< vector<string> >("vector,is_space", is_space() );
  TestBoost< list<string> >("list,is_space", is_space() );
  
  TestBoost< vector<string> >("vector,myIsSpace", myIsSpace );
  TestBoost< list<string> >("list,myIsSpace", myIsSpace );
  
  Test< SplitVK,vector<string> >("VK,vector,function", myIsSpace);
  Test< SplitVK,list<string> >("VK,list,function", myIsSpace);
  
  Test< SplitNoname2,vector<string> >("Noname2,vector,function", myIsSpace);
  Test< SplitNoname2,list<string> >("Noname2,list,function", myIsSpace);
  
  Test< SplitVK,vector<string> >("VK,vector,functor", MyIsSpace() );
  Test< SplitVK,list<string> >("VK,list,functor", MyIsSpace() );
  
  Test< SplitNoname2,vector<string> >("Noname2,vector,functor", MyIsSpace() );
  Test< SplitNoname2,list<string> >("Noname2,list,functor", MyIsSpace() );
  
  return 0;
}

C>Поигравши с лисповыми макрами, мой друг улучьшил время выполнения кода до 0 мс, притом время выполнения совершенно не зависит от N. ))

print 50000

class when:
    patterns = []
    
    def __init__(self, expr):
        when.patterns.append(self)
        self.expr = expr

    def __call__(self, func):
        arg0 = tuple(getargspec(func)[0])
        self.func = func
        
        def _wrap(*args):
            d = dict(zip(arg0, args))
            
            for pattern in when.patterns:
                if pattern.func.__name__ == func.__name__ and eval(pattern.expr, globals(), d):
                    return pattern.func(*args)
                 
            raise TypeError("not find pattern: " + repr(d))
        
        return _wrap

@when("n < 2")
def fib(n):
    return 1

@when("n >= 2")
def fib(n):
    return fib(n - 1) + fib(n - 2)

print fib(8)


@when("a == 0")
def ack(a, b):
    return b + 1

@when("a != 0 and b == 0")
def ack(a, b):
    return ack( a - 1, 1 )

@when("True")
def ack(a, b):
    return ack( a - 1, ack( a, b - 1 ) );

print ack(3, 4)

import std.stdio, std.string, std.perf;

void main()
{
  auto t = new HighPerformanceCounter();
    
  t.start();
  
  uint res = 0;

    for(uint i = 0; i < 1000000; ++i)
    res += split("123 345 asdf 23453 asdfas"," ").length;
                
  t.stop();
    
  writefln("res is ", res ," ", t.milliseconds()," ms elapsed.");
}

using System;
using System.Diagnostics;

class Runner
{
  public static void Main()
  {
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    
    int res = 0;
  
    for(uint i = 0; i < 1000000; ++i)
      res += "123 345 asdf 23453 asdfas".Split(' ').Length;
      
    stopwatch.Stop();
          
    Console.WriteLine("res is {0}, {1} elapsed",
                      res, stopwatch.Elapsed);
  }
}

using System.Console;
using System.Diagnostics;

def stopwatch = Stopwatch();
stopwatch.Start();
  
mutable res = 0;

repeat(1000000)
  res += "123 345 asdf 23453 asdfas".Split(' ').Length;
  
stopwatch.Stop();
      
WriteLine($"res is $res, $(stopwatch.Elapsed) elapsed");

import time

start = time.clock()
      
res = 0
for i in xrange(1000000):
    res += len("123 345 asdf 23453 asdfas".split(" "))
    
finish = time.clock()    
    
print 'res is %s, %f sec elapsed' % ( res, finish - start )

import time
import psyco
psyco.full()

start = time.clock()
      
res = 0
for i in xrange(1000000):
    res += len("123 345 asdf 23453 asdfas".split(" "))
    
finish = time.clock()    
    
print 'res is %s, %f sec elapsed' % ( res, finish - start )

#include <vector>
#include <string>
#include <iostream>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>

#include <windows.h> // for GetTickCount

using namespace std;
using namespace boost::algorithm;

int main()
{
  DWORD start = GetTickCount();
    
  int res = 0;
  for(int i = 0; i < 1000000; i++)
  {
    // так корректней сравнивать, ведь в др программах мы размер не указывали
    // + по моим тестам почти не повлияло на скорость
    vector<string> tokens; 
    split(tokens, "123 345 asdf 23453 asdfas", is_any_of(" "));
    res += tokens.size();
  }

  DWORD stop = GetTickCount();

  cout << "res is " << res << ',' << stop - start << " ms elapsed\n";
  
  return 0;
}

r = 0
for i in xrange(1000000):
    r += len("123 345 asdf 23453 asdfas".split(" "))
    
print r

/*!
    \since v.4.2.7
    \brief Предикат для std::find_if.

    Для очередного состояния проверяет возможность слияния
    с состоянием из другого класса агентов.

    Определяет, есть ли среди всех классов, на которые ссылаются
    состояния, еще не полностью определенные классы.
*/
class    merge_possibility_checker_t
    :    public std::unary_function<
            const state_handler_impl_ptr_vector_t::value_type &,
            bool >
    {
    private :
        /*! Список всех классов. */
        const class_map_t & m_all_classes;

        /*! Список состояний всех классов */
        const std_class_relation_handler_t::class_info_map_t &
            m_classes_state;

        /*! Принимает значение true, если были найдены не
            полностью определенные классы. */
        bool    & m_is_incomplete_class_found;

        /*! Приемник описания ошибки. */
        std::string &    m_error_desc;

    public :
        //! Основной конструктор.
        merge_possibility_checker_t(
            //! Список всех классов.
            const class_map_t & all_classes,
            const std_class_relation_handler_t::class_info_map_t &
                classes_state,
            bool & is_incomplete_class_found,
            //! Приемник описания ошибки.
            std::string & error_desc )
            :    m_is_incomplete_class_found( is_incomplete_class_found )
            ,    m_all_classes( all_classes )
            ,    m_classes_state( classes_state )
            ,    m_error_desc( error_desc )
            {}

        result_type
        operator()( argument_type a );

    private :
        /*! Проверка наличия указанного состояния в указанном
            классе.

            \return true, если состояние найдено. */
        bool
        try_find_state_in_class(
            //! Имя искомого состояния.
            const std::string & state_name,
            //! Класс, в котором состояние нужно найти.
            const class_handler_impl_t & class_handler );
    };

merge_possibility_checker_t::result_type
merge_possibility_checker_t::operator()( argument_type a )
    {
        bool result = false;

        const state_handler_impl_t::merge_list_t & merge_list =
            a->merge_list();

        for( state_handler_impl_t::merge_list_t::const_iterator
                it = merge_list.begin(), it_end = merge_list.end();
            it != it_end;
            ++it )
            {
                bool is_merge_valid = false;

                const state_handler_impl_t::merge_t & m = *it;

                // Должен быть известен класс.
                class_map_t::const_iterator it_class = m_all_classes.find(
                    m.m_class_name );
                if( it_class != m_all_classes.end() )
                    {
                        int state = m_classes_state.find(
                            m.m_class_name )->second.m_state;
                        // Класс должен быть полностью определен.
                        if( std_class_relation_handler_t::state_valid == state )
                            {
                                // Должно быть известно состояние.
                                if( try_find_state_in_class(
                                    m.m_state_name, *( it_class->second ) ) )
                                    // Все хорошо. Поэтому, чтобы перейти к обработке
                                    // следующего состояния, нужно возвратить false.
                                    is_merge_valid = true;
                                else
                                    {
                                        // Состояние не известно.
                                        m_error_desc += std::string( "state '" ) +
                                            a->query_name() +
                                            "' requires merging with undefined state '" +
                                            m.m_state_name + "' from class '" +
                                            m.m_class_name + "';";
                                    }
                            }
                        else if( std_class_relation_handler_t::state_invalid == state )
                            // Нашли ссылку на некорректный класс.
                            m_error_desc += std::string( "state '" ) +
                                a->query_name() +
                                "' requires merging with invalid class '" +
                                m.m_class_name + "';";
                        else
                            {
                                // Класс еще не определен.
                                m_is_incomplete_class_found = true;
                                m_error_desc += std::string( "incomplete class: " ) +
                                    m.m_class_name + ";";
                            }
                    }
                else
                    // Нашли ссылку на неизвестный класс.
                    m_error_desc += std::string( "state '" ) + a->query_name() +
                        "' requires merging with undefined class '" +
                        m.m_class_name + "';";

                // Если текущее слияние не корректно, то и состояние не может
                // быть корректным.
                if( !is_merge_valid )
                    result = true;
            }

        return result;
    }

bool
merge_possibility_checker_t::try_find_state_in_class(
    const std::string & state_name,
    const class_handler_impl_t & class_handler )
    {
        const state_handler_impl_ptr_vector_t & states =
            class_handler.query_state_handlers();
        return ( states.end() != std::find_if(
            states.begin(), states.end(),
            state_by_name_finder_t( state_name ) ) );
    }

int
std_class_relation_handler_t::try_merge_states(
    const class_handler_impl_t & class_handler,
    const class_map_t & all_classes,
    std::string & error_desc )
    {
        // Берем все состояния, которые нуждаются в слиянии.
        state_handler_impl_ptr_vector_t states_for_merging =
            class_handler.states_for_merge();

        // Проверяем возможность проведения слияния.
        bool is_incomplete_class_found = false;
        merge_possibility_checker_t checker( all_classes, m_classes,
            is_incomplete_class_found, error_desc );
        if( states_for_merging.end() != std::find_if(
            states_for_merging.begin(), states_for_merging.end(),
            checker ) )
            // Слияние не возможно. Осталось только определить,
            // по какой причине.
            return ( is_incomplete_class_found ?
                state_not_processed :
                state_invalid );

        // Выполняем слияние.
        std::for_each( states_for_merging.begin(),
            states_for_merging.end(),
            merge_maker_t( all_classes ) );

        return state_valid;
    }

_1 ->* &B::foo
bind(&A::data, _1)

_.foo
_.data

obj => obj.Prop1.Prop2.Prop3

V>Понял, в чем прикол?

int index = 0; 
for_each(a.end(), a.end(), cout << ++index << ':' << _1 << '\n');

[123, 345, asdf, 23453, asdfas]
00:00:00.8376620
5000000
00:00:00.2925531
5000000
00:00:00.7282637
5000000

using System.Console;
using  System.Diagnostics.Stopwatch;

module Parse
{
  public Split(this str : string) : list[string]
  {
    def loop(start, i, lst)
    {
      if (i < str.Length)
        match (str[i])
        {
          | ' ' | '\t' => str.Substring(start, i - start) :: loop(i + 1, i + 1, lst)
          | _ => loop(start, i + 1, lst)
        }
      else if (start == i) lst
      else                 [str.Substring(start, i - start)];
    }

    loop(0, 0, []);
  }

  public Tokenize(this str : string) : System.Collections.Generic.IEnumerable[(int * int)]
  {
    def loop(start, i)
    {
      if (i < str.Length)
        match (str[i])
        {
          | ' ' | '\t' =>
            yield (start, i - start);
            loop(i + 1, i + 1)

          | _ => loop(start, i + 1)
        }
      else if (start != i) yield (start, i - start)
      else                 ()
    }

    loop(0, 0);
  }
}

////////////////////////// Далее идут тесты /////////////////////////////////

WriteLine(Parse.Split("123 345 asdf 23453 asdfas"));

/////////////////////////////////////////////////////////////////////////////
// Тестируем сплит написанный что называется в стиле "мама не горюй" (с динамическими списками).
def timer = StartNew();

mutable count = 0;
for(mutable i = 0; i < 1000000; ++i)
  count += Parse.Split("123 345 asdf 23453 asdfas").Length;

WriteLine(timer.Elapsed);
WriteLine(count);

/////////////////////////////////////////////////////////////////////////////
// Тестируем бибилиотечный сплит.
def timer = StartNew();

count = 0;
for(mutable i = 0; i < 1000000; ++i)
  foreach (_ in Parse.Tokenize("123 345 asdf 23453 asdfas"))
    count++;

WriteLine(timer.Elapsed);
WriteLine(count);

/////////////////////////////////////////////////////////////////////////////
// Тестируем токенайзер.
def timer = StartNew();

count = 0;
for(mutable i = 0; i < 1000000; ++i)
  count += "123 345 asdf 23453 asdfas".Split().Length;

WriteLine(timer.Elapsed);
WriteLine(count);

_ = ReadLine();

typedef function2<
                    match_type, 
                    input_iterator_type, 
                    input_iterator_type> finder_type;
...

private:
                // Finder
                finder_type m_Finder;

#include <algorithm>
#include <string>
#include <set>

template< class Finder >
class Finder_Holder
    {
    private :
        Finder finder_;

    public :
        Finder_Holder( Finder finder )
            :    finder_( finder )
            {}

        void
        operator()( char c ) { finder_( c ); }
    };

class Finder
    {
    private :
        std::set< char >    tokens_;

    public :
        Finder( std::string tokens )
            :    tokens_( tokens.begin(), tokens.end() )
            {}

        bool
        operator()( char c )
            {
                return tokens_.end() == tokens_.find( c );
            }
    };

Finder_Holder< Finder >
is_any_of( const std::string & value )
    {
        return Finder_Holder< Finder >( Finder( value ) );
    }

template< class Predicate >
void
do_something( const std::string & s, Predicate pred )
    {
        std::for_each( s.begin(), s.end(), pred );
    }

void
test()
    {
        for( int i = 0; i != 1000000; ++i )
            do_something( "123 345 asdf 23453 asdfas", is_any_of( " " ) );
    }

int
main()
    {
        test();

        return 0;
    }

bash-3.1$ time t1.exe

real    0m5.172s
user    0m0.031s
sys     0m0.000s

#include <algorithm>
#include <string>
#include <set>

template< class Finder >
class Finder_Holder
    {
    private :
        const Finder & finder_;

    public :
        Finder_Holder( const Finder & finder )
            :    finder_( finder )
            {}

        void
        operator()( char c ) const { finder_( c ); }
    };

class Finder
    {
    private :
        std::set< char >    tokens_;

    public :
        Finder( const std::string & tokens )
            :    tokens_( tokens.begin(), tokens.end() )
            {}

        bool
        operator()( char c ) const
            {
                return tokens_.end() == tokens_.find( c );
            }
    };

Finder_Holder< Finder >
is_any_of( const std::string & value )
    {
        return Finder_Holder< Finder >( Finder( value ) );
    }

template< class Predicate >
void
do_something( const std::string & s, const Predicate & pred )
    {
        std::for_each( s.begin(), s.end(), pred );
    }

void
test()
    {
        const Finder_Holder< Finder > pred = is_any_of( " " );
        for( int i = 0; i != 1000000; ++i )
            do_something( "123 345 asdf 23453 asdfas", pred );
    }

int
main()
    {
        test();

        return 0;
    }

bash-3.1$ time t2.exe

real    0m0.406s
user    0m0.015s
sys     0m0.015s

FR>REBOL [] res: 0
FR>probe loop 1000000 [res: res + length? parse "123 345 asdf 23453 asdfas" { }]
FR>

FR>3.6 секунды

do[1000000;&"123 345 asdf 23453 asdfas"=" "]

template <class C, class S, class P>
inline void split(C & c, const S & str, P & is_delimiter)
{
    bool next_token = false;
    typename S::const_iterator it = str.begin(), end = str.end(), token_start = it;
    for(; it != end; ++it)
    {
        if (next_token)
        {
            next_token = false;
            token_start = it;
        }
        if (is_delimiter(*it))
        {
            if (token_start != it)
                c.push_back(S(token_start, it));
            next_token = true;
        }
    }
    if (!next_token && (token_start != it))
        c.push_back(S(token_start, it));
}

inline bool is_space(const char c)
{
    return c == ' ';
}

int main()
{
    int r = 0;

    vector<string> tokens(5);
    string str("123 345 asdf 23453 asdfas");

    for(int i = 0; i < 1000000; ++i)
    {
        tokens.erase(tokens.begin(),tokens.end());
        split(tokens, str, is_space);
        r += tokens.size();
    }

    cout << r << endl;
    return 0;
}

V>>>var(obj).Prop1.Prop2
V>>>

NB>>так юзать не получится

V>template<typename T>
V>var_type<T&>::type lvar(T& obj) { return obj; }
V>

bind(&A::Prop1, _1);

>> Так что если очень хочется то и паттерн матчинг можно сделать

@when("isinstance(x, basestring)")
def my_print(x):
    print '<' + x + '>'
       
@when("isinstance(x, list)")
def my_print(x):
    print "["
    for i in x:
        my_print(i)
    print "]"
    
@when("True")
def my_print(x):
    print x

PA>прыгать надо .

repeat(1000000)
    count += Parse.Split("123 345 asdf 23453 asdfas").Length;

foreach(_ in $[1 .. 1000000])
    count += Parse.Split("123 345 asdf 23453 asdfas").Length;

In sum, var(x) creates a nullary lambda functor, which stores a reference to the variable x. When the lambda functor is invoked, a reference to x is returned.

var(obj).Prop1.Prop2

var(obj.Prop1).Prop2

int r = 0;

vector<string> tokens(5);

for(int i = 0; i < 1000000; i++)
{
    split(tokens, "123 345 asdf 23453 asdfas", is_any_of(" "));
    r += tokens.size();
}

int res = 0;
    
for(int i = 0; i < 1000000; i++)
    res += "123 345 asdf 23453 asdfas".Split(' ').Length;
            
Console.WriteLine(res);

D>то заместо ~20 сек., получаем ~5 сек., на VC++ 8.0.

#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

int main(int argc, char *argv[])
{
int r = 0;
vector<string> tokens(5);

for(int i = 0; i < 1000000; i++)
{
    istringstream istr("123 345 asdf 23453 asdfas");
    string word;
    int k = 0;
    
    while(!istr.eof())
    {
    istr >> word;
    tokens[k++] = word;
    }
    
    r += k;
}

cout << r << endl;

return 0;
}

#include <deque>
#include <string>
#include <iostream>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>

#ifdef OS_WINDOWS
#include <windows.h> // for GetTickCount
#else // posix
#include <sys/times.h>
#endif

using namespace std;
using namespace boost::algorithm;

int main()
{
#ifdef OS_WINDOWS
  DWORD start = GetTickCount();
#else
struct tms t;
  clock_t start = times(&t);
#endif
    
  int res = 0;
  for(int i = 0; i < 1000000; i++)
  {
    // так корректней сравнивать, ведь в др программах мы размер не указывали
    // + по моим тестам почти не повлияло на скорость
    deque<string> tokens; 
    split(tokens, "123 345 asdf 23453 asdfas", is_any_of(" "));
    res += tokens.size();
  }

 #ifdef OS_WINDOWS
  DWORD stop = GetTickCount();
#else
  clock_t stop = times(&t);
#endif

  cout << "res is " << res << ',' << stop - start << " ms elapsed\n";
  
  return 0;
}

module Main where

import System.CPUTime (getCPUTime)

{- меня заленило лезть в документацию и искать функцию аналогичную split,
   поэтому я реализовал её сам. -}
split :: (a -> Bool) -> [a] -> [[a]]
split _ [] = []
split p l  = case break p l
             of { (b, [])     -> [b]
                ; ([], _)     -> [[]]
                ; (b, (e:[])) -> [b]
                ; (b, (e:ex)) -> b : (split p ex)
                }

fun :: Int -> Int
fun = fun' 0
    where
    fun' :: Int -> Int -> Int
    fun' l n | n <= 0 = l
             | otherwise 
                 = fun'
                   {- следующая строка вычисляется только 1 раз, 
                      в качестве первого аргумента функции fun' 
                      всегда передается одно и тоже значение. -}
                   (l + (length (split (==' ') "123 345 asdf 23453 asdfas"))) 
                   (n - 1)
       
main :: IO ()
main = do { begin <- getCPUTime
          ; putStr "Res is "
          ; (putStr . show . fun) 1000000
          ; putStr ", "
          ; end <- getCPUTime
          ; (putStr . show) (((fromInteger (end - begin)) :: Double) / (1000000000 :: Double))
          ; putStrLn " ms. elapsed."
          }

from time import clock

t1 = clock()
print len(("123 345 asdf 23453 asdfas " * 1000000).split(" "))
t2 = clock()

print t2 - t1

from time import clock

t1 = clock()
print sum([len("123 345 asdf 23453 asdfas".split(" "))] * 1000000)
t2 = clock()

print t2 - t1

#!/bin/sh
# restart using tclsh \
exec tclsh "$0" "$@"

set _len 0
set x [time {
    for {set x 0} {$x<1000000} {incr x} {
        incr _len [llength [split "123 345 asdf 23453 asdfas"]]
    }
}]
puts $x
puts $_len
puts "done"

void MyF1(vector<int>& vec, int s)
{
    transform(vec.begin(), vec.end(), vec.begin(), (s + _1));
}

?MyF1@@YAXAAV?$vector@HV?$allocator@H@std@@@std@@H@Z PROC ; MyF1, COMDAT
    mov    eax, DWORD PTR _vec$[esp-4]
    mov    ecx, DWORD PTR [eax+4]
    mov    edx, DWORD PTR [eax+8]
    mov    eax, ecx
    cmp    eax, edx
    push    esi
    push    edi
    je    SHORT $LN71@MyF1
    mov    esi, DWORD PTR _s$[esp+4]
$LL82@MyF1:
    mov    edi, DWORD PTR [eax]
    add    edi, esi
    mov    DWORD PTR [ecx], edi
    add    eax, 4
    add    ecx, 4
    cmp    eax, edx
    jne    SHORT $LL82@MyF1
$LN71@MyF1:
    pop    edi
    pop    esi
    ret    0

#include <stdio.h>
#include <string.h>
#include <time.h>

class tokenizer
{
public:
    enum sep_flag
    {
        single,
        multiple,
        whole_str
    };

    struct token
    {
        const char* ptr;
        unsigned    len;
    };

    tokenizer(const char* sep, 
              const char* trim=0,
              const char* quote="\"",
              char mask_chr='\\',
              sep_flag sf=multiple);

    void set_str(const char* str)
    {
        m_src_string = str; 
        m_start = 0;
    }

    token next_token();

private:
    
    // This function should actually be a template parameter
    static int check_chr(const char *str, char chr)
    {
        return chr == ' ';//int(strchr(str, chr));
    }

private:
    const char* m_src_string;
    int         m_start;
    const char* m_sep;
    const char* m_trim;
    const char* m_quote;
    char        m_mask_chr;
    unsigned    m_sep_len;
    sep_flag    m_sep_flag;
};

//-----------------------------------------------------------------------
tokenizer::tokenizer(const char* sep, 
                     const char* trim,
                     const char* quote,
                     char mask_chr,
                     sep_flag sf) :
    m_src_string(0),
    m_start(0),
    m_sep(sep),
    m_trim(trim),
    m_quote(quote),
    m_mask_chr(mask_chr),
    m_sep_len(sep ? strlen(sep) : 0),
    m_sep_flag(sep ? sf : single)
{
}


//-----------------------------------------------------------------------
tokenizer::token tokenizer::next_token()
{
    unsigned count = 0;
    char quote_chr = 0;
    token tok;

    tok.ptr = 0;
    tok.len = 0;
    if(m_src_string == 0 || m_start == -1) return tok;

    register const char *pstr = m_src_string + m_start;

    if(*pstr == 0) 
    {
        m_start = -1;
        return tok;
    }

    int sep_len = 1;
    if(m_sep_flag == whole_str) sep_len = m_sep_len;

    if(m_sep_flag == multiple)
    {
        while(*pstr && check_chr(m_sep, *pstr)) 
        {
            ++pstr;
            ++m_start;
        }
    }

    if(*pstr == 0) 
    {
        m_start = -1;
        return tok;
    }

    for(count = 0;; ++count) 
    {
        char c = *pstr;
        int found = 0;

        if(quote_chr == 0)
        {
            if(sep_len == 1)
            {
                found = check_chr(m_sep, c);
            }
            else
            {
                found = strncmp(m_sep, pstr, m_sep_len) == 0; 
            }
        }

        ++pstr;

        if(c == 0 || found) 
        {
            if(m_trim)
            {
                while(count && 
                        check_chr(m_trim, m_src_string[m_start]))
                {
                    ++m_start;
                    --count;
                }

                while(count && 
                        check_chr(m_trim, m_src_string[m_start + count - 1]))
                {
                    --count;
                }
            }

            tok.ptr = m_src_string + m_start;
            tok.len = count;

            m_start += count;
            if(c) 
            {
                m_start += sep_len;
                if(m_sep_flag == multiple)
                {
                    while(check_chr(m_sep, m_src_string[m_start])) 
                    {
                        ++m_start;
                    }
                }
            }
            break;
        }

        if(quote_chr == 0)
        {
            if(check_chr(m_quote, c)) 
            {
                quote_chr = c;
                continue;
            }
        }
        else
        {
            if(m_mask_chr && c == m_mask_chr)
            {
                if(*pstr) 
                {
                    ++count;
                    ++pstr;
                }
                continue; 
            }
            if(c == quote_chr) 
            {
                quote_chr = 0;
                continue;
            }
        }
    }
    return tok;
}


int main()
{
    tokenizer tokens(" ", "", "", 0, tokenizer::multiple);
    char dst[100];

    double tm1 = clock();
    for(int i = 0; i < 1000000; ++i)
    {
        tokens.set_str("123 345 asdf 23453 asdfas");
        for(;;)
        {
            tokenizer::token tok = tokens.next_token();
            if(tok.ptr == 0) break;
            if(tok.len)
            {
                // ATTN: DON'T DO THAT! Use std::vector<std::string> instead
                memcpy(dst, tok.ptr, tok.len); 
                dst[tok.len] = 0;
            }
        }
    }
    double tm2 = (clock() - tm1) / CLOCKS_PER_SEC;
    printf("%f\n", tm2);

    return 0;
}

split(tokens, "123 345 asdf 23453 asdfas", is_any_of(' '));

FR>>r = 0
FR>>for i in xrange(1000000):
FR>>    r += len("123 345 asdf 23453 asdfas".split(" "))
    
FR>>print r 
FR>>

FR>>отрабатывает за 2.5 секунды

using System;

class MainApp 
{
    public static void Main() 
    { 
        int res = 0;
    
        for(int i = 0; i < 1000000; i++)
            res += "123 345 asdf 23453 asdfas".Split(' ').Length;
            
        Console.WriteLine(res);
    }
}

Samples     Address        Code Bytes             Instruction                  Symbol      CPU 0     
10          0x7c902f10     0x 0B C0               or eax,eax                   tan+210     10        
20          0x7c902f12     0x 74 0C               jz $+0eh (0x7c902f20)        tan+212     20        
29          0x7c902f14     0x 8D 4A FF            lea ecx,[edx-01h]            tan+214     29        
14          0x7c902f17     0x 8B 18               mov ebx,[eax]                tan+217     14        
            0x7c902f19     0x F0 0F C7 4D 00      lock cmpxchg8b [ebp+00h]                           
2842        0x7c902f1e     0x 75 F0               jnz $-0eh (0x7c902f10)       tan+224     2842

struct bad_const_str
{
    const char *ptr;

    const_str()
    {
        ptr = NULL;
    }

    const_str(const char *pa, const char *pb)
    {
        ptr = pa;
    }
};

from time import clock
import psyco
psyco.full()

def run():
    res = 0
    for i in xrange(1000000):
        res += len("123 345 asdf 23453 asdfas".split(" "))
    return res


start = clock()
res = run()   
finish = clock()    
    
print 'res is %s, %f sec elapsed' % ( res, finish - start )

CC>Бо что то мне кажется что тут надо в "консерватории" что то подправить

REBOL [] res: 0
probe loop 1000000 [res: res + length? parse "123 345 asdf 23453 asdfas" { }]

#include <iostream>
#include <vector>
#include <boost/algorithm/string/split.hpp>

using namespace std;
using boost::algorithm::split;

inline bool is_space(char c)
{
return c == ' ';
}

int main(int argc, char *argv[])
{
int r = 0;

vector<string> tokens(5);

for(int i = 0; i < 1000000; i++)
{
    split(tokens, "123 345 asdf 23453 asdfas", is_space);
    r += tokens.size();
}

return 0;
}

АХ>Надо идти к ним на форум ругаться

#include <iostream>
#include <string>
#include <vector>

using namespace std;

void split(vector<string> &out, const char *text, bool (*pred)(char))
{
out.erase(out.begin(), out.end());
const char *begin_word = text;
for(; *text; ++text)
 {
  const char c = *text;
  if(pred(c))
  {
  out.push_back(string(begin_word, text - begin_word));
  begin_word = text + 1;
  }
 }
 
if(text != begin_word)
 out.push_back(string(begin_word, text - begin_word));
}


inline bool is_space(char c)
{
return c == ' ';
}

int main(int argc, char *argv[])
{
int r = 0;

vector<string> tokens(5);

for(int i = 0; i < 1000000; i++)
{
    split(tokens, "123 345 asdf 23453 asdfas", is_space);
    r += tokens.size();
}

cout << r << endl;

/*for(int i = 0; i < tokens.size(); ++i)
 {
 cout << tokens[i] << endl;
 }*/

return 0;
}

template <class C, class S, class P>
inline void split(C & c, const S & str, P & is_delimiter)
{
    typename S::const_iterator it = str.begin(), token_start = it, end = str.end();
    for(; it != end; ++it)
    {
        if (is_delimiter(*it))
        {
            if (token_start != it)
                c.push_back(S(token_start, it));
            ++(token_start = it);
        }
    }
    if (token_start != it)
        c.push_back(S(token_start, it));
}

void my_split(vector<char*> &res, char *str, const char separator[])
{
    char *token = strtok( str, separator );

    while( token != NULL )
    {    
        res.push_back( token );
        token = strtok( NULL, separator );
    }
}