I can’t stop asking myself the same question: is it still possible for a new language to make a breakthrough like C and C+ did at the time?

Mxx_ru::setup_target(
    Mxx_ru::Cpp::Lib_target.new( "aag_3/sms_data_type/prj.rb" ) {

        required_prj "oess_1/defs/prj.rb"

        target_root "lib"
        target "aag_3.sms_data_type" + Aag_3::VERSION

        cpp_source "types.cpp"

        sources_root( "smpp2smsg" ) {
            cpp_source "pub.cpp"
            cpp_source "tag.cpp"
        }

        sources_root( "smsg2smpp" ) {
            cpp_source "pub.cpp"
            cpp_source "tag.cpp"
        }
    }
)

<project type="library" alias="aag_3/sms_data_type/prj">
    <required_prj alias="oess_1/defs/prj.rb" />
    
    <target_root name="lib" />
    <target name="aag_3.sms_data_type" version_suffix="Aag_3::VERSION" />
    
    <cpp_source name="types.cpp" />
    
    <sources_root name="smpp2smsg">
        <cpp_source name="pub.cpp"/>
        <cpp_source name="tag.cpp"/>
    </sources_root>

    <sources_root name="smsg2smpp">
        <cpp_source name="pub.cpp"/>
        <cpp_source name="tag.cpp"/>
    </sources_root>
</project>

c.field :name => :source_addr_ton,
        :type => "oess_1::uchar_t",
        :bit_mask => 0x1,
        :default => 0

c.field( { :name => :source_addr_ton,
        :type => "oess_1::uchar_t",
        :bit_mask => 0x1,
        :default => 0 } )

class MailTruck
    def self.company( name )
        meta_def :company do; name; end
    end
end

class HappyTruck < MailTruck
    company "Happy's -- We Bring the Mail, and That's It!" 
end

h = HappyTruck.new
h.company

class HappyTruck < MailTruck
    def company
        "Happy's -- We Bring the Mail, and That's It!"
    end
end

class My
    attr_accessor :my_attr
end

class My
    # Метод getter.
    def my_attr
        @my_attr
    end
    
    # Метод setter.
    def my_attr=( v )
        @my_attr = v
    end
end

class Date
    ...
    once :day_fraction
    ...
    def day_fraction
        <какие-то вычисления>
    end
    ...
end

class Date
    def calc_day_fraction
        <какие-то вычисления>
    end
    
    def day_fraction
        # Вычисляем атрибут @day_fraction только если он не был вычислен ранее.
        @day_fraction = calc_day_fraction unless @day_fraction
        @day_fraction
    end
end

class Project < ActiveRecord::Base
    belongs_to              :portfolio
    has_one                 :project_manager
    has_many                :milestones
    has_and_belongs_to_many :categories
end

• Project#portfolio, Project#portfolio=(portfolio), Project#portfolio.nil?
  
• Project#project_manager, Project#project_manager=(project_manager), Project#project_manager.nil?,
  
• Project#milestones.empty?, Project#milestones.size, Project#milestones, Project#milestones<<(milestone), Project#milestones.delete(milestone), Project#milestones.find(milestone_id), Project#milestones.find_all(conditions), Project#milestones.build, Project#milestones.create
  
• Project#categories.empty?, Project#categories.size, Project#categories, Project#categories<<(category1), Project#categories.delete(category1)

• В отличии от Lisp-а Ruby остается чисто императивным языком с превычным большинству программистов синтаксисом. Для меня это означает, во-первых, что не требуется адаптации к птичьему Lisp-синтаксису и, во-вторых, что на Ruby можно писать нормальный императивный код.
  
• В отличии от Lisp-а имеется одна основная ветвь разработки Ruby и одна единая реализация, портированная на массу платформ. Еще более важно, что есть единая стандартная библиотека (постоянно и оперативно развиваемая) и централизованная вокруг Ruby community. Достижением этого community является, например, система управления пакетами RubyGems.

E>class MailTruck
E>    def self.company( name )
E>        meta_def :company do; name; end
E>    end
E>end
E>

E>class HappyTruck < MailTruck
E>    company "Happy's -- We Bring the Mail, and That's It!" 
E>end
E>

HappyTruck::company

E>h = HappyTruck.new
E>h.company
E>

class MailTruck
    def self.company( name )
        class_def :company do; name; end
    end
end

>>> a = lambda x: x*x
>>> a(5)
25

>>> b = lambda x: if x>0 : x*x
File "<stdin>", line 1
b = lambda x: if x>0 : x*x
^
SyntaxError: invalid syntax

sources_root( "impl" ) {
    cpp_source "a.cpp"
    cpp_source "b.cpp"
    
    sources_root( "win32" ) {
        cpp_source "c.cpp"
    }
    
    sources_root( "posix" ) {
        cpp_source "d.cpp"
    }
}

П>уже нельзя.

b = lambda(x): (x>0)and(x*x)or(-x)

print b(-1)
print b(-2)
print b(0)
print b(4)

void foo(void (*fn)())
{
  fn();
}

void (*)() bar(string word)
{
  struct A {
    static void baz() {
      cout << "Me a de " << word << " nuttah" << endl;
    }
  };
  return &A::baz;
}

int main()
{
  foo(bar("original")); // выводит Me a de original nuttah
  foo(bar("mad")); // выводит Me a de mad nuttah
}

def foo(f):
    f()

def bar(w):
    def l():
        print "Me a de", w, "nuttah"
    return l

foo(bar("original"))
foo(bar("mad"))

>>> def a(): print "aa"
>>> def b(): print "bb"
>>> def c(func): func()
>>> c(a)
aa
>>> c(b)
bb

П>А можно чуть поподробнее? А то не зная рубийного синтаксиса трудно понять, даже с теми комментариями, что ниже.

t = Target.new

# Устанавливаем новый текущий путь и сохраняем предыдущий чтобы восстановить его позже.
pre_impl = t.sources_root( t.current_sources_root() + "/impl" )

# Теперь имена C++ файлов будут относительно impl.
t.cpp_source( "a.cpp" )
t.cpp_source( "b.cpp" )

# Ныряем вглубь impl/win32.
pre_win32 = t.sources_root( t.current_sources_root() + "/win32" )
t.cpp_source( "c.cpp" )
# И выходим из него.
t.sources_root( pre_win32 )

# Ныряем вглубь impl/posix.
pre_posix = t.sources_root( t.current_sources_root() + "/posix" )
t.cpp_source( "d.cpp" )
# И выходим из него.
t.sources_root( pre_posix )

# Выходим из impl.
t.sources_root( pre_impl )

t = Target.new { # Вот это начало блока.
                 # Все последующие вызовы неявно выполняются для экземпляра t.
                                 
    # За вызовом sources_root скрыто:
    # pre = t.current_sources_root() + "/impl".
    # Затем вызов блока, код которого выполняется для объекта t.
    # t.sources_root( pre ).
    sources_root( "impl" ) {
        # t.cpp_source...
        cpp_source( "a.cpp" )
        # t.cpp_source...
        cpp_source( "b.cpp" )
        
        # Дальше то же самое.
    }
}

# Сменить путь, относительно которого задаются имена
# исходных файлов. Если установить пустую строку,
# то нужно будет задавать полные имена файлов.
# Если задан блок, то путь меняется на новый, блок выполняется,
# после чего старое значение пути восстанавливается.
#
# Возвращает предыдущее значение mxx_sources_root. Актуально
# для случая, когда метод вызывается без параметра-блока.
def    sources_root( a_root )
    old_root = @mxx_sources_root.clone
    if block_given?
        @mxx_sources_root = File.join( [ @mxx_sources_root, a_root ] )
        yield
        @mxx_sources_root = old_root
    else
        @mxx_sources_root = a_root
    end

    return old_root
end

4.7.5 Lambda Forms

By popular demand, a few features commonly found in functional programming languages and Lisp have been added to Python. With the lambda keyword, small anonymous functions can be created. Here's a function that returns the sum of its two arguments: "lambda a, b: a+b". Lambda forms can be used wherever function objects are required. They are syntactically restricted to a single expression. Semantically, they are just syntactic sugar for a normal function definition. Like nested function definitions, lambda forms can reference variables from the containing scope:

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43