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

grid.Source = from c in customers   
              join o in orders on c equals o.Customer into oo   
              select new { c.CompanyName, OrderCount = oo.Count()

Нет, потому что штатно LINQ2SQL этого не поддерживает, а расширять генерацию SQL можно будет только в следующей версии.

LET F = "string"

LET E$ = "string"

x := alpha * p + omega * s;

for(i = 0; i < x.Length; i++)
{
    x[i] = alpha * p[i] + omega * s[i];
}

r := b - A*x;

The single biggest criticism that can be launched against Template Haskell is the lack of compelling applications. We have explored a handful of scenarios in which Template Haskell would be useful, the coolest, albiet unimplemented, being the universal algebraic-fold. But the list of possible applications that we have assembled doesn't warrant the technical effort that Template Haskell represents; nor do the examples that Simon Peyton Jones and Tim Sheard provide in their paper... And so the most interesting question is, perhaps, why the scope of Template Haskell's applicability seems to be so narrow.

macro repeatmacro (times, body)
syntax ("repeat", "(", times, ")", body)
{
  <[ for (mutable t = $times; t > 0; --t) $body ]>
}

C>class UI
C>{
C>  void OnLoad()
C>  {
C>    binder.List = myMapper.select("from c in Customer select c").list();
C>  }
C>}
C>

#A = 0;

A type C is said to be a collection type if it implements the System.Collections.IEnumerable interface or implements the collection pattern by meeting all of the following criteria:
• C contains a public instance method with the signature GetEnumerator() that returns a struct-type, class-type, or interface-type, which is called E in the following text.
• E contains a public instance method with the signature MoveNext() and the return type bool.
• E contains a public instance property named Current that permits reading the current value. The type of this property is said to be the element type of the collection type.
A type that implements IEnumerable is also a collection type, even if it doesn't satisfy the conditions above.

foreach pred xs f = mapM f (filter pred xs)

1. Вы можете отфильтровать нужные элементы по типу. Например, предположим, что вам требуется из общего списка членов (typeMembers) некоторого типа отфильтровать только те элементы, которые реализуют интерфейс IMethod (то есть являются методами). Это можно сделать следующим образом:

foreach (method is IMethod in typeMembers)
  processMethod(method);

foreach (`is` IMethod) typeMembers processMethod

2. Вы можете использовать защиту, чтобы обработать только нужные элементы. Например, вот так можно исключить из обработки элементы, значения которых равны null:

foreach (elem when elem != null in someList)
  process (elem);

foreach (!= null) someList process

Другой пример – вы можете захотеть обработать только публичные методы:

foreach (method is IMethod when method.IsPublic in typeMembers)
  processMethod(method);

foreach (\method -> method `is` IMethod && isPublic method) typeMembers processMethod

when :: (a -> Bool) -> (a -> Bool) -> (a -> Bool)
when f g x = f x && g x

foreach ((`is` IMethod) `when` isPublic) typeMembers processMethod

3. Вы можете указывать один образец варианта. При этом будут отфильтрованы только те элементы, которые соответствуют этому образцу:

def expressions = [Literal(1.23), Mul(Literal(2), Literal(3))];
foreach (Mul(_, _) as mul in expressions)
  WriteLine(mul);

expressions = [Literal 1.23, Mul (Literal 2, Literal 3)]
forM [ mul | mul@Mul{} <- expressions ] print

expressions = [Literal 1.23, Mul (Literal 2, Literal 3)]

foreach isMul expressions print
        where
                isMul Mul{} = True
                isMul _     = False

3. (кстати, почему опять три?!) Вы можете производить декомпозицию вариантов и кортежей непосредственно при объявлении элемента в foreach:

def expressions = [Literal(1.23), Mul(Literal(2), Literal(3))];
foreach (Mul(e1, e2) as mul in expressions)
  WriteLine($"$(mul.Eval()) = $e1 * $e2");

expressions = [Literal 1.23, Mul (Literal 2, Literal 3)]

-- решение на LH
forM [ mul | mul@(Mul e1 e2) <- expressions ] print (e1*e2)

-- решение на универсальном комбинаторе
foreach isMul expressions (\(Mul e1 e2) -> print (e1 * e2))
        where
                isMul Mul{} = True
                isMul _     = False

4. Самый сложный случай практически аналогичен анонимному применению match в функциях:

def expressions = [Literal(1.23), Mul(Literal(2), Literal(3))];

foreach (expr in expressions)
{
  | Mul(e1, e2) => WriteLine($"$(expr.Eval()) = $e1 * $e2");
  | Div(e1, e2) => WriteLine($"$(expr.Eval()) = $e1 * $e2");
  ...
}

expressions = [Literal 1.23, Mul (Literal 2, Literal 3)]

-- пусть будет ещё один комбинатор - предикат, всегда возвращающий True
ok = const True

foreach ok expressions $ \expr ->
        case expr of
                Mul e1 e2 -> ...
                Div e1 e2 -> ...
                
-- разумеется всё что после $ можно вынести в отдельную (вложенную) функцию, чтобы избавиться от case и expr.

val res = db.executeStatement {
select fields ("name" of characterVarying(50)) from "person"
}

IT>>>Java — суксь Немерля — the dest

К>>От destiny?

IT>Очепятался

$theirStupidLanguage - суксь :))) Немерля - the Best :super:

- Жгут и убивают СС — а мы солдаты, мы воюем.
— А что, изобрели какой-нибудь новый способ воевать — без убийств и бомбежек?
(17 мгновений весны, диалог Штирлица и пьяного генерала в поезде)

Ну вот лежит книга Брауна "Макропроцессоры и мобильность ПО".
Подробно рассматриваются разные типы макропроцессоров и способы их применения. Связанные с этим преимущества и сложности.
Цитата:

Не так давно возникла тенденция создавать языки с большой степенью встроенной расширяемости, и они были названы "расширяемыми языками". Встроенная расширяемость может быть реализована, по крайней мере частично, за счет макросов, но такие макросы должны составлять единое целое с компилятором базового языка.
1974 год.

Не так давно возникла тенденция создавать языки с большой степенью встроенной расширяемости, и они были названы "расширяемыми языками". Встроенная расширяемость может быть реализована, по крайней мере частично, за счет макросов, но такие макросы должны составлять единое целое с компилятором базового языка.

L>Это тоже вряд ли сойдёт за аргумент

ага. И каждый ваш новоопределенный макрос — каждый, делает этот язык все более навороченным — причем, без контроля и толковых спецификаций. Что может быть и ускорит разработку, когда вы работаете в одиночку, но приведет к катастрофе, если над проектом работает большая группа. Сразу напишете неподдерживаемый код, который потом в помойку пойдет через пару лет.

inductiveSet constants rules = concat (iterate derive constants)
    where derive elems = concat [ rule elems | rule <- rules ]

-- тип данных 
data Expr = Const Int | Expr :+: Expr | Expr :-: Expr

-- преобразование выражения в строку
instance Show Expr where
    show (Const n) = show n    
    show (x :+: y) = showBinop "+" x y
    show (x :-: y) = showBinop "-" x y

showBinop op x y = printf "(%s %s %s)" (show x) op (show y)

-- правила вывода

binop op exprs = [ x `op` y | x <- exprs, y <- exprs ]
addition = binop (:+:)
subtraction = binop (:-:)

-- выражения
expressions = inductiveSet [Const x | x <- [0..5]] [addition, subtraction]

*Main> take 50 expressions
[0,1,2,3,4,5,(0 + 0),(0 + 1),(0 + 2),(0 + 3),(0 + 4),(0 + 5),(1 + 0),(1 + 1),(1 + 2),(1 + 3),(1 + 4),(1 + 5),(2 + 0),(2 + 1),(2 + 2),(2 + 3),(2 + 4),(2 + 5),(3 + 0),(3 + 1),(3 + 2),(3 + 3),(3 + 4),(3 + 5),(4 + 0),(4 + 1),(4 + 2),(4 + 3),(4 + 4),(4 + 5),(5 + 0),(5 + 1),(5 + 2),(5 + 3),(5 + 4),(5 + 5),(0 - 0),(0 - 1),(0 - 2),(0 - 3),(0 - 4),(0 - 5),(1 - 0),(1 - 1)]

data Person = MkPerson { personName :: String, personAge :: Int }

instance Typeable Person where
    typeOf _ = mkTyConApp (mkTyCon "Main.Person") []
        
instance Data Person where
        toConstr person =
                mkDataConstr (dataTypeOf person) "MkPerson" Prefix
        dataTypeOf person = ... -- неохота писать, смысл ясен полагаю.

VD>Значит такие макросы.

L>>Да и вообще все языки Тьюринг-полные

enum Color { red, green, blue }
...
int rgb(Color c) {
  switch (c) {
  case red: return 0xff;
  case green: return 0xff00;
  case blue: return 0xff0000;
  }
}

final class Color extends Enum {
  public static final red = new Color(0,"red");
  public static final green = new Color(1,"green");
  public static final blue = new Color(2,"blue");
  private Color(int ord, String name) { super(ord,name); }
  ...
}
...
int rgb(Color c) {
  switch (c.ordinal()) {
  case 0: return 0xff;
  case 1: return 0xff00;
  case 2: return 0xff0000;
  default: throw new Error();
  }
}

r := b - A*x;

<...>

E>void
E>main()
E>    {
E>        const int vector_size = 5;
E>        float a_src[ vector_size ] = { 1, 2, 3, 4, 5 };
E>        float b_src[ vector_size ] = { 0.5, 1.5, 2.5, 3.5, 4.5 };

E>        vector_t a( a_src, a_src + vector_size );
E>        vector_t b( b_src, b_src + vector_size );
E>        vector_t d( b_src, b_src + vector_size );
E>        vector_t c;

E>        c << 0.0 * a + 2.0 * b - 1 * d + b / 0.2;

E>        std::cout << c << std::endl;
E>    }
E>

E>((a1 * v + a2 * v2)/0.5 - (a3*v3 - a4*v4)*2) * 0.75;
E>

macro for (init, cond, change, body)
{
  <[ 
    $init;
    def loop () : void {
      if ($cond) { $body; $change; loop() } 
      else ()
    };
    loop ()
  ]>
}

macro for (init, cond, change, body)
{
  Label lbl_cont = new Label();
  Label lbl_check = new Label();
  Label lbl_break = new Label();
  return new Block(
    init,
    new Goto(lbl_check),
    lbl_cont,
    body,
    change,
    lbl_check,
    new IfElse(
      cond, // condition
      new Goto(lbl_cont), // then
      null  // else
    ),
    lbl_break
  )
}

L>Э-э-э не понял. Это же мой пост