value := aDictionary at: aKey ifAbsent: [...обрабатываем ситуацию...].

V value = aMap.get(key);
if (value == null) {...обрабатываем ситуацию...}

ADD UserInput TO RunningTotal
        ON SIZE ERROR DISPLAY "Error - new total too large for data-item."
        NOT ON SIZE ERROR ADD 1 TO IterCount END-ADD
END-ADD

К>Сишные конструкции тоже не сразу становятся привычными

К>Я говорил о разнице в синтаксисе, которая имеет смысл из каких-либо соображений, из того же удобства каких-то операций и т.п. В том же лиспе скобки из-за единства данных и кода, в форте — из-за стековой организации вычислений. Зачем наречие мумбо-юмбо тебе нужно, я не улавливаю

(1=1) ifTrue: ['hello' out].

value := aDictionary at: aKey ifAbsent: [...обрабатываем ситуацию...].

V value = aMap.get(key);
if (value == null) {...обрабатываем ситуацию...}

условие ? то-то : что-то;

public ParseQualIdent(text : string) : list[string]
{
    def str = System.Text.StringBuilder();

    def parseComment(chars, name, continuation)
    {
        match (chars)
        {
            | '\n' :: tail
            | '\r' :: '\n' :: tail
            | '\r' :: tail => continuation(tail, name)
            | _ => parseComment(chars, name, continuation)
        }
    }

    def parseMultilineComment(chars, name, continuation)
    {
        match (chars)
        {
            | '*' :: '/' :: tail => continuation(tail, name)
            | _ => parseMultilineComment(chars, name, continuation)
        }
    }

    def parse(chars, name : list[string])
    {
        match (chars)
        {
            | '/' :: '/' :: tail => parseComment(tail, name, parse)
            | '/' :: '*' :: tail => parseMultilineComment(tail, name, parse)
            | '.' :: tail => def x = str.ToString(); str.Length = 0; parse(tail, x :: name);
            | x :: tail when char.IsLetterOrDigit(x) || x == '_' => ignore(str.Append(x)); parse(tail, name);
            | _ :: tail => parse(tail, name);
            | [] => str.ToString() :: name
        }
    }

  // Explode преобразует строку в список символов
    parse(text.Explode(), []).Rev()
}

ANS>условие ? то-то : что-то;
ANS>

if (условие) то-то else что-то

begin
  WriteLn('2 + 2 = ', 2 + 2);
end.

public ParseQualIdent(text : string) : list[string]
    def str = System.Text.StringBuilder();
    def parseComment(chars, name)
        match (chars)
            | '\n' :: tail \
            | '\r' :: '\n' :: tail \
            | '\r' :: tail => parse(tail, name)
            | _ => parseComment(chars, name)
    and parseMultilineComment(chars, name)   
        match (chars)
            | '*' :: '/' :: tail => parse(tail, name)
            | _ => parseMultilineComment(chars, name)
    and parse(chars, name : list[string])
        match (chars)
            | '/' :: '/' :: tail => parseComment(tail, name)
            | '/' :: '*' :: tail => parseMultilineComment(tail, name)
            | '.' :: tail => def x = str.ToString(); str.Length = 0; parse(tail, x :: name)
            | x :: tail when char.IsLetterOrDigit(x) || x == '_' => ignore(str.Append(x)); parse(tail, name)
            | _ :: tail => parse(tail, name)
            | [] => str.ToString() :: name

    // Explode преобразует строку в список символов
    parse(text.Explode(), []).Rev()

VD>Я кого хочешь, в чем хочешь прощу, если мне обяснят суть этой вещи . Я уже видел подобный код в компиляторе, но так его и не понял к своему стыду. Поясни, плиз, его смысл.

// здесь функция parse недоступна
def parseComment() { parse() } // ошибка
def parse() { }
// локальные функции и значения доступны в коде следующем за их объявлением
// and как бы объединяет объявление нескольких локальных функций в одно объявление
// и они становятся доступными друг для друга
def parseComment() { parse() } // ok
and parse() { }

aValue := aDictionary at: aKey ifAbsent: [return nil].
... тут идёт, при котором aValue всегда имеет корректное значение ...

IT>А мне короткого ?: ужасно не хватает

using Nemerle.Compiler;

[assembly: Nemerle.Internal.OperatorAttribute ("Nemerle.Core", "?", false, 209, 210)]

namespace Nemerle.Core
{
    macro @?(lhs, rhs)
    {
        match(rhs)
        {
            | <[ $exprTrue : $exprFalse ]> =>
                <[ if ($lhs) $exprTrue else $exprFalse ]>
            // здесь должно быть нормальное сообщение об ошибке
            | _ => Message.FatalError("bla-bla-bla")
        }
    }
}

if (!msgs.Tables.Contains("message"))
    return 0;
DataTable msgTable = msgs.Tables["message"];

msgTable := msgs tables at: 'messages' ifAbsent: [^0].

/**
 * Returns an optional value associated with the specified key.
 */
public Get (key : 'a) : option ['b]
{
    mutable value;
    
    if (TryGetValue (key, out value))
        Some (value)
    else
        None ()
}
        
public TryGetValue (key : 'a) : 'b * bool
{
    mutable value;
    
    if (TryGetValue (key, out value))
        (value, true)
    else
        (value, false)
}

/**
 * Returns value associated with the specified key or default value (null for 
 * referece type and result of parameterless constractor for value type).
 */
public GetValueOrDefault (key : 'a) : 'b
{
    mutable value;
    
    ignore (TryGetValue (key, out value));
    
    value
}    

/**
 * Returns value associated with the specified key or defaultValue.
 */
public GetValueOrDefault (key : 'a, defaultValue : 'b) : 'b
{
    mutable value;
    
    if (TryGetValue (key, out value))
        value
    else
        defaultValue
}

/**
 * Returns value associated with the specified key or result of call getDefaultValue().
 * The getDefaultValue() called only if key not exists in collection.
 */
public GetValueOrGetDefault (key : 'a, getDefaultValue : void -> 'b) : 'b
{
    mutable value;
    
    if (TryGetValue (key, out value))
        value
    else
        getDefaultValue()
}

def lst = hashtab.GetValueOrGetDefault(someKey, () => List()); // List создатстся только если ключа нет.
lst.Add(...);
...

def count = hashtab.GetValueOrDefault(someKey, 0);
...

match (hashtab.Get())
{
    | Some(1) => // что-то делаем
    | Some(2) => // что-то делаем
    | Some(x) => // что-то делаем с 'x'
    | None    => // ключа нет в хэш-таблице
}

def (value, exists) = hashtab.TryGetValue(someKey);
if (exists)
 doSomethingWithValue(value)
else
 doSomethingElse();

ANS>if (!msgs.Tables.Contains("message"))
ANS>    return 0;
ANS>DataTable msgTable = msgs.Tables["message"];
ANS>

ANS>msgTable := msgs tables at: 'messages' ifAbsent: [^0].
ANS>

DataTable msgTable = msgs.Tables["message"]; if (msgTable.Absent)  return 0;

ANS>msgTable := msgs tables at: 'messages' ifAbsent: [^0].
ANS>

Ты не устаешь меня радовать. Я то думал, имя Грэхема тебе знакомо. А ты оказывается просто проигнорировал его, как и любой другой незнакомый тебе термин
ответ очень прост — большие компании консервативны и неповоротливы, они не могут извлечь пользу из новых технологий. Но стартапы этим не страдают, и они давно бы воспользовались любой технологией, которая может дать им преимущество. Хотя бы малейшее.
Поскольку я не вижу волны таких стартапов, построенных на "элитарных языках", я делаю простой вывод — все их преимущества высосаны из пальца.