LCR>CL-USER 1 > (defstruct point x y z)
LCR>POINT
...
LCR>CL-USER 4 > (setf my-point (make-point :x 3 :y 4 :z 12))
LCR>#S(POINT X 3 Y 4 Z 12)
...
LCR>CL-USER 5 > (type-of my-point)
LCR>POINT
LCR>

[Nemerle.Compiler.SupportRelocation]
public partial class TypeBuilder : TypeInfo
{
....
}

[CompilerGenerated]
internal override void RelocateImplInternal(RelocationInfo info)
{
  ... // код этого метода генерируется на основании информации о типе того типа 
        // к которому добавляется этот метод.
}

this.имяПоля = Completion.Relocate(this.имяПоля, info);

this.имяПоля = x.Map(Completion.Relocate(_, info));

(defmacro once-only ((&;rest names) &body body)
  (let ((gensyms (loop for n in names collect (gensym))))
    `(let (,@(loop for g in gensyms collect `(,g (gensym))))
      `(let (,,@(loop for g in gensyms for n in names collect ``(,,g ,,n)))
        ,(let (,@(loop for n in names for g in gensyms collect `(,n ,g)))
           ,@body)))))

(defclass person ()
  ((name :type 'string)
   (age :type 'integer))
  )

(defmethod bla-bla-bla ((self person))
  (format t "~&Nemerle Rulez Foreva!!!~%"))

(defmethod bla-bla-bla2 ((self person) (additional string))
  (format t "~&Nemerle Rulez Foreva!!! ~A~%" additional))

(defmethod bla-bla-bla3 ((self person) (times integer))
  (format t "~&Nemerle Rulez Foreva ~A times!!!~%" times))

(mapcar
  #'(lambda (slot)
      (format t "~&Field Name: ~A, Type: ~A~%"
              (slot-definition-name slot)
              (second (slot-definition-type slot))))
  (class-direct-slots (find-class 'person)))

(mapcar
  #'(lambda (method)
      (format t "~&Method Name: ~A, Lambda-list: ~A, Function: ~A~%"
              (generic-function-name (method-generic-function method))
              (method-lambda-list method)
              (method-generic-function method)
              ))
  (specializer-direct-methods (find-class 'person)))

Field Name: NAME, Type: STRING
Field Name: AGE, Type: INTEGER
Method Name: BLA-BLA-BLA3, Lambda-list: (SELF TIMES), Function: #<STANDARD-GENERIC-FUNCTION BLA-BLA-BLA3>
Method Name: BLA-BLA-BLA2, Lambda-list: (SELF ADDITIONAL), Function: #<STANDARD-GENERIC-FUNCTION BLA-BLA-BLA2>
Method Name: BLA-BLA-BLA, Lambda-list: (SELF), Function: #<STANDARD-GENERIC-FUNCTION BLA-BLA-BLA>

<[ def x = $expr; ]>

aArray[rand()] <-> aArray[rand()]

macro @<-> (e1, e2)
{
  def (cached1, safe1) = Operators.cache_assign_expr (e1);
  def (cached2, safe2) = Operators.cache_assign_expr (e2);    
  <[
    $cached1;
    $cached2;
    def tmp = $safe1;
    $safe1 = $safe2;
    $safe2 = tmp;
  ]>
}

module Operators
{
  [Hygienic]
  internal cache_assign_expr (e : PT.PExpr)
  : PT.PExpr * PT.PExpr
  {
    def desc =
      match (e) {
        | <[ $tab [$idx] ]> =>
          def new_idx = <[ $(Macros.NewSymbol () : name) ]>;
          CacheDesc (<[ $tab [$new_idx] ]>, <[ def $new_idx = $idx ]>)

        | <[ $tab [.. $idxes] ]> =>
          def idx_exprs = List.Map (idxes, _ => <[ $(Macros.NewSymbol () : name) ]>);
          CacheDesc (<[ $tab [.. $idx_exprs] ]>, <[ def (.. $idx_exprs) = (.. $idxes) ]>)

        | _ =>
          CacheDesc (e, null)
      }

    ( <[ $(TExpr.Cache (desc, null) : typed) ]>, 
      <[ $(TExpr.CacheRef (desc) : typed) ]> )
  }
}