___>(op arg1 arg2 arg3 ...)
___>

___>(infix 1 + 2 * 4)
___>

using System;
using System.Console;
using Nemerle;
using OverloadedList;

namespace IgnoreNullOperator
{
  class A { public i : int = 2; }
  class B { public a : IgnoreNullOperator.A = null; }
  class C { public a : IgnoreNullOperator.B = null; }
  module Test
  {
    public Test() : void
    {
      WriteLine("--------- Begin '?.' test ---------");
      def b1 = IgnoreNullOperator.B();
      
      WriteLine(b1?.a?.i);
      
      for (mutable str = null; str?.Length <= 4; str += "Test")
      {
        WriteLine(str?.ToString() + "s");
        WriteLine(str?.Length);
        //WriteLine(str?.[0]);
      }
      
      WriteLine("--------- End '?.' test ---------");
    }
  }
}

Однако мне кажется, что я могу дать убедительный аргумент. Исходный текст редактора Viaweb на 20-25 процентов состоял из макросов. Макросы сложнее писать, чем обычные функции Lisp'а, и считается дурным тоном использовать их там, где можно без них обойтись. Поэтому каждый макрос в той программе был необходим. Это значит, что примерно 20-25 процентов кода в программе делают то, что нельзя просто сделать на других языках.

class A
{  
  public func() : void
  {
    private c = 0;

    //код использующий c
  }
}

(define make-pos (row col)
  (cons row col))

(define get-row (pos)
  (car pos))

(define get-col (pos)
  (cdr pos))

public SomeType MyFunction(ReferenceType1 param1, ReferenceType2 param2, ValueType param3)
{
  Guard.CheckNotNull(param1, "param1");
  Guard.CheckNotNull(param2, "param2");
  ...
}

try
{
    file.assign(fname);
    file.open();
    // do something
    file.process();
}
finally
{
    file.close();
}

(with-open-file (file fname)
    (file.process))

(with-open-file (in-file "input.txt")
    (parse-data in-file)
    (print "file parsed"))

(defmacro with-open-file (file fname rest &body)
    `(try
         (,file.assign ,fname)
         (,file.open)
         ,@body)
         (finally
             (,file.close))))

var open-file = function (file, fname, action) {
                             try {
                                 file.assign(fname);
                                 file.open();
                                 action();
                             }
                             finally {
                                 file.close();
                             }

open-file("input1.txt", in-file1, function () { in-file1.process(); });
open-file("input2.txt", in-file2, function () { in-file2.process(); });

var while = function (i, cond, body) {
                       loop {
                           if (cond(i))
                               body(i);
                           else
                               break;
                       }
                   }

var i = 0;
while(i, func (i) { i < 10 }, func (i) { print(i); });

foo = notnull $ \x -> notnull $ \y -> \z ->
    x + y + z

var camelCased(some_name) = 34; // SomeName = 34;
SomeName = 22;

0>public SomeType MyFunction(ReferenceType1 param1, ReferenceType2 param2, ValueType param3)
0>{
0>  Guard.CheckNotNull(param1, "param1");
0>  Guard.CheckNotNull(param2, "param2");
0>  ...
0>}
0>

void CheckNotNulls(params object[] args)
{
  // и тут бы дергал для каждого параметра CheckNotNull
}

public SomeType MyFunction(ReferenceType1 param1, ReferenceType2 param2, ValueType param3)
{
  Guard.CheckNotNulls(param1, param2);
  ...
}

<[ decl:
    ..$attrs
    class $(name : usesite) : $anonymous_ref, System.IEquatable[ $ty_ref ] {
        ..$members
    }
]>

keyword "(" expression ")" expression

(op arg1 arg2 arg3 ...)

(infix 1 + 2 * 4)

История Мака: обычная такая история
Когда-то, давным-давно, жила-была компания Lisp программистов. Это было так давно, что в Lisp даже не существовало макросов. Каждый раз все то, что не могло быть определено с помощью функций или сделано с помощью специализированных операторов, должно было быть написано в полном объеме, что было довольно трудоемким делом. К сожалению, программисты в этой компании были хоть и блестящи, но очень ленивы. Нередко в своих программах, когда процесс написания больших объемов кода становился слишком утомителен, они вместо кода писали комментарии, описывающие требуемый в этом месте программы код. К еще большему сожалению, из-за своей лени программисты также ненавидели возвращаться назад и действительно писать код, описанный в комментариях. Вскоре компания получила большую кучу кода, которую никто не мог запустить, потому что он был полон комментариев с описанием того, что еще предстоит написать.

В отчаянии большой босс нанял младшего (junior) программиста, Мака, чьей работой стал поиск комментариев, написание требуемого кода и вставка его в программу на место комментариев. Мак никогда не запускал программы, ведь они не были завершены и поэтому он попросту не мог этого сделать. Но даже если бы они были завершены, Мак не знал, какие данные необходимо подать на их вход. Поэтому он просто писал свой код, основываясь на содержимом комментариев, и посылал его назад создавшему комментарий программисту.

С помощью Мака все программы вскоре были доделаны, и компания заработала уйму денег продавая их: так много денег, что смогла удвоить количество программистов. Но по какой-то причине никто не думал нанимать кого-то в помощь Маку; вскоре он один помогал нескольким дюжинам программистов. Чтобы не тратить все свое время на поиск комментариев в исходном коде, Мак внес небольшие изменения в используемый программистами компилятор. Теперь, если компилятор встречал комментарий, то отсылал его электронной почтой Маку, а затем ждал ответа с замещающим комментарий кодом. К сожалению, даже с этими изменениями Маку было тяжело удовлетворять запросам программистов. Он работал так тщательно, как только мог, но иногда, особенно когда записи не были ясны, он допускал ошибки.

Однако программисты обнаружили, что чем точнее они пишут свои комментарии, тем больше вероятность того, что Мак вернет правильный код. Как-то раз один из программистов, встретив затруднение с описанием в словах нужного кода, включил в один из комментариев программу на Lisp, которая генерировала нужный код. Такой комментарий был удобен Маку: он просто запустил программу и послал результат компилятору.

Следующее новшество появилось, когда программист вставил в самый верх одной из своих программ комментарий, содержащий определение функции и пояснение, гласившее: "Мак, не пиши здесь никакого кода, но сохрани эту функцию на будущее; я собираюсь использовать ее в некоторых своих комментариях." Другие комментарии в этой программе гласили следующее: "Мак, замени этот комментарий на результат выполнения той функции с символами x и y как аргументами."

Этот метод распространился так быстро, что в течение нескольких дней большинство программ стало содержать дюжины комментариев с описанием функций, которые использовались только кодом в других комментариях. Чтобы облегчить Маку различение комментариев, содержащих только определения и не требующих немедленного ответа, программисты отмечали их стандартным предисловием: "Definition for Mac, Read Only" (Определение для Мака, только для чтения). Это (как мы помним, программисты были очень ленивы) быстро сократилось до "DEF. MAC. R/O", а потом до "DEFMACRO".

Очень скоро в комментариях для Мака вообще не осталось английского. Целыми днями он читал и отвечал на электронные письма от компилятора, содержащие DEFMACRO комментарии и вызывал функции, описанные в DEFMACRO. Так как Lisp программы в комментариях осуществляли всю реальную работу, то работа с электронными письмами перестала быть проблемой. У Мака внезапно стало много свободного времени, и он сидел в своем кабинете и грезил о белых песчаных пляжах, чистой голубой океанской воде и напитках с маленькими бумажными зонтиками.

Несколько месяцев спустя программисты осознали что Мака уже довольно давно никто не видел. Придя в его кабинет, они обнаружили, что все покрыто тонким слоем пыли, стол усыпан брошюрами о различных тропических местах, а компьютер выключен. Но компилятор продолжал работать! Как ему это удавалось? Выяснилось, что Мак сделал заключительное изменение в компиляторе: вместо отправки электронного письма с комментарием Маку компилятор теперь сохранял функции, описанные с помощью DEFMACRO комментариев, и запускал при вызове их из других комментариев. Программисты решили, что нет оснований говорить большим боссам, что Мак больше не приходит на работу. Так происходит и по сей день: Мак получает зарплату и время от времени шлет программистам открытки то из одной тропической страны, то из другой.

max@progressor ~
$ cat test.lisp
"aa

max@progressor ~
$ clisp test.lisp
*** - READ: input stream
      #<INPUT BUFFERED FILE-STREAM CHARACTER #P"test.lisp" @2> ends within a
      string

(defun bad-read (str c)
    (do ((chr (read-char str) (read-char str))
             (agg (make-array 5 :fill-pointer 0 :adjustable t :element-type 'character)))
        ((not (digit-char-p chr))
         (unread-char chr str)
         (multiple-value-bind (v x) (parse-integer (reverse agg)) v))
        (vector-push chr agg)))

(set-macro-character #\? #'bad-read) 

(format t "~a" ?321)

int main(int argc, char** argv) {
   int x;
   y = 3;
}

VD>Что-то я не улавливаю в этих словах логики.

WH>Ты хотябы псевдокод напиши.

make r = PExpr.Member e1 `ap` make' r where
    make' (Ref n) = Splicable.Name n
    make' (ToComplete n) = Splicable.HalfId
    make' _ = failMatch
e2 <- msum [
    r ~~> make r
    Call(r, parms) ~~> PExpr.Call `ap` make r `ap` parms
    Indexer(r, parms) ~~> PExpr.Indexer `ap` make r `ap` parms
    otherwise ~~> Message.FatalError "blabla"] expr2
-- ...

make r = PExpr.Member e1 `ap` make' r where
    make' (Ref n) = Splicable.Name n
    make' (ToComplete n) = Splicable.HalfId
    make' _ = failMatch
e2 <- runExprT $ msum $ map ExprT [
    \r -> make r
    \Call(r, parms) -> PExpr.Call `ap` make r `ap` parms
    \Indexer(r, parms) -> PExpr.Indexer `ap` make r `ap` parms
    \_ -> Message.FatalError "blabla"] expr2

    def loc = expr2.Location;
    def makeMemberAccess(n) { PExpr.Member(loc,  <[ e1 ]>, Splicable.Name(loc, n)) }
    def makeComplation  (n) { PExpr.Member(loc,  <[ e1 ]>, Splicable.HalfId(loc, n)) }
    def e2 = 
      match (expr2)
      {
        | Ref(n)                    => makeMemberAccess(n)
        | Call(Ref(n), parms)       => PExpr.Call(loc, makeMemberAccess(n), parms)
        | Indexer(Ref(n), parms)    => PExpr.Indexer(loc, makeMemberAccess(n), parms)
        | ToComplete(n)             => makeComplation(n)
        | Call(ToComplete(n), _)    => makeComplation(n)
        | Indexer(ToComplete(n), _) => makeMemberAccess(n)
        | _ => Message.FatalError(expr2.Location, $"The expression of this ($(expr2.GetType())) type not supported with operator '?.'");
      };