("text" 1 2)

(f ("text" 1 2))

("строка" символы ...)

;sapp.scm
#lang scheme
(provide (except-out (all-from-out scheme) #%app)
         (rename-out [app #%app]))
(define-syntax-rule (app f x ...)
  ;; note that applications in the resulting pattern use our own
  ;; `#%app' implicitly
  (begin (if (string? f)
             (with-output-to-string (lambda () (printf f x ...)))
             (f x ...))))

;test.scm
#lang s-exp "sapp.scm"
("~s + ~s = ~s" 1 2 3) ;-> "1 + 2 = 3"

[f, 1, 2, 3]

MC>;("text" 1 2)
MC>;

MC>;(f ("text" 1 2))
MC>;

MC>[f, 1, 2, 3]
MC>

public Filter[T](this seq : SCG.IEnumerable[T], predicate : T -> bool) : list[T]
{
  $[ x | x in seq, predicate (x) ]
}

  macro ExpandListComprehension (params exprs : list [PExpr])
  {
    def adder =
      <[
         def cell = $(exprs.Head) :: [];
         if (head == null) {
           head = cell;
           tail = cell;
         } else {
           _N_skip_write_check (tail.tl) = cell;
           tail = cell;
         }
       ]>;
       
    def loops =
      exprs.Tail.Rev ().FoldLeft (adder,
        fun (e, acc) {
          match (ListComprehensionHelper.ExpandRange (e, acc)) {
            | Some (expr) => expr
               
            | None =>
              match (e) {
                | <[ $e1 in $e2 ]> =>
                  <[ foreach ($e1 in $e2) $acc ]>
                | cond =>
                  <[ when ($cond) $acc ]>
              }
          }
        });

    match (exprs) {
      | [<[ $second .. $last ]>] =>
        <[ $[ x | x in [$second .. $last]] ]>

      | [<[ $first ]>, <[ $second .. $last ]>] =>
        <[ $[ x | x in [$first, $second .. $last]] ]>
        
      | _ =>
        <[
            mutable head = null;
            mutable tail = null;
            $loops;
            if (head == null)
              []
            else
              head
        ]>
    }
  } 

  public module ListComprehensionHelper
  {
    [Nemerle.Macros.Hygienic]
    public ExpandRange (inrange : PExpr, acc : PExpr) : option [PExpr]
    {
      match (inrange) {
        | <[ $pat in $[$first, $second .. $last] ]>
        | <[ $pat in [$first, $second .. $last] ]> =>
          Some (<[
             mutable i = $first;
             mutable delta = $second - i;
             def last = $last;
             mutable cond = if (delta < 0) i >= last else i <= last;             
             def pre_last = unchecked (last - delta);
             
             when (delta < 0 && pre_last < last || delta > 0 && pre_last > last) // we overflowed
               delta = -delta;
               
             while (cond) {
               def $pat = i;
               if (delta < 0) 
                 cond = i >= pre_last;
               else 
                 cond = i <= pre_last;
               unchecked (i += delta);
               $acc;
             }
          ]>)
           
        | <[ $pat in $[$first .. $last] ]>
        | <[ $pat in [$first .. $last] ]> =>
          Some (<[
             mutable i = $first;
             def last = $last;
             mutable cond = i <= last;
             mutable pre_last = last;
             unchecked (pre_last--); // can't use (last - 1) since 1 might change/widen type
             def overflowed = pre_last > last;
             while (cond) {
               def $pat = i;
               if (overflowed)
                 cond = i >= pre_last;
               else
                 cond = i <= pre_last;
               unchecked (i++);
               $acc;
             }
          ]>)

        | _ => None ()
      }
    }
  }

  [PegGrammar(sum, 
  grammar
  {
    any           = ['\u0000' .. '\uFFFF'];
    letter        = ['a' .. 'z'] / ['A' .. 'Z'] / '_';
    digit         = ['0' .. '9'];
    spaces        = ' '*;
    id     : Expr = (letter (digit / letter)*) spaces;
    num    : Expr = digit+ spaces;
    expr'  : Expr = '(' spaces sum ')' spaces;
    expr   : Expr = num / id / expr';
    sum    : Expr = expr ('+' spaces expr)* spaces;
    start  : Expr = spaces sum spaces !any;
  })]
  class TestSum
  {
    // обработчики вызываемые при разборе текста
  }

def g = DefineGramar(  grammar
  {
    any           = ['\u0000' .. '\uFFFF'];
    letter        = ['a' .. 'z'] / ['A' .. 'Z'] / '_';
    digit         = ['0' .. '9'];
    spaces        = ' '*;
    id     : Expr = (letter (digit / letter)*) spaces;
    num    : Expr = digit+ spaces;
    expr'  : Expr = '(' spaces sum ')' spaces;
    expr   : Expr = num / id / expr';
    sum    : Expr = expr ('+' spaces expr)* spaces;
    start  : Expr = spaces sum spaces !any;
  });

def result = g.Parse("1 + 2");

<[ $("a" : global) ...; $("b" : dyn) ....; c ...; /* или */ $("c" : name)]>

CL-USER> (declaim  (optimize speed
                             (safety 0)
                             (space 0)
                             (debug 0)))
T
CL-USER> (defun my-func (x)
           (declare (fixnum x))
           (the fixnum (1+ x)))
MY-FUNC
CL-USER> (compile 'my-func)
MY-FUNC
NIL
NIL
CL-USER> (disassemble 'my-func)
;; disassembly of #<Function MY-FUNC>
;; formals:

;; code start: #x2083517c:
   0: 83 c0 04    addl    eax,$4
   3: f8          clc
   4: 8b 75 fc    movl    esi,[ebp-4]
   7: c3          ret

cl-user> (disassemble 'my-func)
; disassembly for my-func
; 034511BF:       4883C208         add rdx, 8
;       C3:       488BE5           mov rsp, rbp
;       C6:       F8               clc
;       C7:       5D               pop rbp
;       C8:       C3               ret

VD><[ $("a" : global) ...; $("b" : dyn) ....; c ...; /* или */ $("c" : name)]>
VD>

(define-syntax loop
  (lambda (x)
    (syntax-case x ()
      [(k e ...)
       (with-syntax
          ([break (datum->;syntax #’k ’break)]) ;Прошу прощения за вставленный форматтером коммент после стрелки, там его быть не должно
          #’(call-with-current-continuation
              (lambda (break)
                (let f () e ... (f)))))])))

(let ((n 3) (ls ’()))
  (loop
  (if (= n 0) (break ls))
  (set! ls (cons ’a ls))
  (set! n (- n 1))))

basic(
  10 SIN
  20 GOTO HELL)

A>CL-USER> (declaim  (optimize speed
A>                             (safety 0)
A>                             (space 0)
A>                             (debug 0)))
A>T
A>CL-USER> (defun my-func (x)
A>           (declare (fixnum x))
A>           (the fixnum (1+ x)))
A>MY-FUNC
A>CL-USER> (compile 'my-func)
A>MY-FUNC
A>NIL
A>NIL
A>CL-USER> (disassemble 'my-func)
A>;; disassembly of #<Function MY-FUNC>
A>;; formals:

A>;; code start: #x2083517c:
A>   0: 83 c0 04    addl    eax,$4
A>   3: f8          clc
A>   4: 8b 75 fc    movl    esi,[ebp-4]
A>   7: c3          ret
A>

module Program
{
  Inc(x : int) : int { x + 1 }
  
  Main() : void
  {
    WriteLine(Inc(5));
  }
}

0000000b  mov         ecx,6 
00000010  call        FFFFFFFFEF5EDD40