AG>Хотелось бы иметь JIT .

data: {
  one: 1;
  two: "text";
}

switch(String.charCodeAt(idx))
{
  case 'a': ....
  case 'b': ....
}

CS>>data: {
CS>>  one: 1;
CS>>  two: "text";
CS>>}
CS>>

data: 
{
  one: 1,
  two: "text",
  three: new Date( 2005, 9, 12 ),
  four: ["Masha", "Vova", "Vasya" ]
}

G>С чего бы это вдруг? "Ведь наши ученые доказали, что любая форма жизни, у которой нет щупальцев, не может обладать разумом"?

G>Термин typeless просто на удивление "удачен". Например, он совсем не означает, что типов в языке нет и что компилятор/рантайм их не может определить.

Think of Psyco as a kind of just-in-time (JIT) compiler, a little bit like Java's, that emit machine code on the fly instead of interpreting your Python program step by step. The difference is that Psyco writes several version of the same blocks (a block is a bit of a function), which are optimized by being specialized to some kinds of variables (a "kind" can mean a type, but it is more general). The result is that your unmodified Python programs run faster.

Benefits

2x to 100x speed-ups, typically 4x, with an unmodified Python interpreter and unmodified source code, just a dynamically loadable C extension module.

Drawbacks

Psyco currently uses a lot of memory. It only runs on Intel 386-compatible processors (under any OS) right now. There are some subtle semantic differences (i.e. bugs) with the way Python works; they should not be apparent in most programs.

G>>Термин typeless просто на удивление "удачен". Например, он совсем не означает, что типов в языке нет и что компилятор/рантайм их не может определить.

CS>Benefits

CS>2x to 100x speed-ups, typically 4x, with an unmodified Python interpreter and unmodified source code, just a dynamically loadable C extension module.

AG>Не знаю . Но раз потянул парсинг XML-я и csv, которым и без него в общем-то хорошо, то тут уж сам бог велел

AG>???!!!! И сколько же таких расширений накопится по мере расширения продукта? А ведь их еще придется потом поддерживать, баги править .

<Target
  Name="Build"
  Condition=" '$(InvalidConfigurationWarning)' != 'true' "
  Outputs="$(TargetPath)"
  DependsOnTargets="$(BuildDependsOn)"
  />

CS>switch(String.charCodeAt(idx))
CS>{
CS>  case 'a': ....
CS>  case 'b': ....
CS>}
CS>

call @8VariantSum

CS>data: 
CS>{
CS>  one: 1,
CS>  two: "text",
CS>  three: new Date( 2005, 9, 12 ),
CS>  four: ["Masha", "Vova", "Vasya" ]
CS>}
CS>

In Ruby, the class is never (OK, almost never) the type. Instead, the type of an object is
defined more by what that object can do. In Ruby, we call this duck typing. If an object
walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it
were a duck.

class Customer
    def initialize(first_name, last_name)
        @first_name = first_name
        @last_name = last_name
    end
    def append_name_to_file(file)
        file << @first_name << " " << @last_name
    end
end

require 'test/unit'
require 'addcust'

class TestAddCustomer < Test::Unit::TestCase
    def test_add
        c = Customer.new("Ima", "Customer")
        
        f = File.open("tmpfile", "w") do |f|
            c.append_name_to_file(f)
        end
        
        f = File.open("tmpfile") do |f|
            assert_equal("Ima Customer", f.gets)
        end
    ensure
        File.delete("tmpfile") if File.exist?("tmpfile")
    end
end

require 'test/unit'
require 'addcust'

class TestAddCustomer < Test::Unit::TestCase
    def test_add
        c = Customer.new("Ima", "Customer")
        f = ""
        c.append_name_to_file(f)
        assert_equal("Ima Customer", f)
    end
end

require 'test/unit'
require 'addcust'

class TestAddCustomer < Test::Unit::TestCase
    def test_add
        c = Customer.new("Ima", "Customer")
        f = []
        c.append_name_to_file(f)
        assert_equal(["Ima", " ", "Customer"], f)
    end
end

class Customer
    {
        std::string    first_name_;
        std::string    last_name_;
    public :
        ...
        template< class Receiver >
        void append_name_to_file( Receiver & f )
            {
                f << first_name_ << " " << last_name_;
            }
    };

// Обертка для предоставления возможности сохранения содержимого Customer в строку.
class String_As_Receiver
    {
        std::string &    receiver_;
    public :
        String_As_Receiver( std::string & receiver ) : receiver_( receiver ) {}
        
        String_As_Receiver &
        operator<<( const std::string & what )
            {
                receiver_.append( what );
                return *this;
            }
    };
    
// Обертка для предоставления возможности сохранения содержимого Customer в вектор (список, дек).
template< class Container >
class    Container_As_Receiver
    {
        Container &    receiver_;
    public :
        Container_As_Receiver( Container & receiver ) : receiver_( receiver ) {}
        
        Container_As_Receiver &
        operator<<( const std::string & what )
            {
                receiver_.push_back( what );
                return *this;
            }
    };
    
// А теперь использование всего этого безобразия.
Customer c( "Ima", "Customer" );

{
    std::ofstream f( "tmpfile" );
    c.append_name_to_file( f );
}

{
    std::string s;
    String_As_Receiver r( s );
    c.append_name_to_file( r );
}

{
    std::vector v;
    Container_As_Receiver r( v );
    c.append_name_to_file( r );
}

def csv_from_row(op, row)
    res = ""
    until row.empty?
        entry = row.shift.to_s
        if /[,"]/ =~ entry
            entry = entry.gsub(/"/, '""')
            res << '"' << entry << '"'
        else
            res << entry
        end
        res << "," unless row.empty?
    end
    op << res << CRLF
end

result = ""
query.each_row {|row| csv_from_row(result, row)}
http.write result

def csv_from_row(op, row)
    # Код не изменился.
end

result = []
query.each_row {|row| csv_from_row(result, row)}
http.write result.join

types {
    class Dog {
        MakeSound() : String {
            return "woof";
        }
        GetNumLegs() : Int {
            return 4;
        }
        GoFetch() {
            // ...
        }
    }

    class Duck {
        GetNumLegs() : Int {
            return 2;
        }
        MakeSound() : String {
            return "quack";
        }
        FlySouth() {
            // ...
        }
    }

    interface IAnimal {
        MakeSound() : String;
        GetNumOfLegs() : Int;
        // Был бы еще вот такой метод.
        GoAway();
    }
}

functions {
    _main() {
        IAnimal& animal;
        Dog dog;
        Duck duck;
        // Здесь следовало бы ожидать ошибку, т.к. у Dog нет метода GoAway.
        animal = @dog;
        P(animal.MakeSound()); // outputs woof
        // И здесь так же.
        animal = @duck;
        P(animal.MakeSound()); // outputs quack
    }
}

class Dog
    def make_sound; "woof" end
    def get_num_legs; 4 end
    def go_fetch; end
end

class Duck
    def make_sound; "quack" end
    def get_num_legs; 2 end
    def fly_south; end
end

class Cat
    def make_sound; "miau" end
    def get_num_legs; 4 end
    def go_away!; puts "Frrrrr!" end
end

def play_with_animal( animal )
    sound = animal.make_sound
    if "woof" != sound && "quack" != sound
        animal.go_away!
    else
        puts "I like animal with sound '#{sound}'"
    end
end

play_with_animal Dog.new
play_with_animal Duck.new
play_with_animal Cat.new

I like animal with sound 'woof'
I like animal with sound 'quack'
Frrrrr!

19. A language that doesn't affect the way you think about programming, is not worth knowing.

Новый русский приезжает в магазин антикварных музыкальных инструментов:
-- Слышь, мне чисто конкретно для братана подарок нужен! Он типа музыку уважает.
-- Вот, пожалуйста, специально для вас есть уникальная вещь: барабан работы великого итальянского мастера Страдивари.
Новый русский покупает барабан, уезжает, вручает подарок. Над ним смеются:
-- Да тебя развели: Страдивари скрипки пилил!
Новый русский хватает свою братву и уносится на разборки в магазин. Через полчаса возвращается довольный:
-- Не пацаны, все нормально. Страдивари для лохов скрипки пилил. А для реальных пацанов -- барабаны!