[Model] // макрос, генерирующий свойства и атрибуты маппинга по схеме БД (пока просто из заглушки)
class Doctor
{
}

[DbManager] // это гипотетический макрос...
class Db: DbManager
{
    public Doctors : Table[Doctor] //... который должен генерить вот такие свойства для кажого класса модели
    {
        get { this.GetTable.[Doctor]();}
    }
}

[MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Class)]
macro Model(tb : TypeBuilder) {
   ModelImpl.RegisterType(tb);
}

[MacroUsage(MacroPhase.WithTypedMembers, MacroTargets.Class)]
macro Model(tb : TypeBuilder) {
  // основная логика макроса
}

module ModelImpl {

    types : List[TypeBuilder] = List();

    public RegisterType(tb : TypeBuilder) : void {
        types.Add(tb);
    }

}

user.get(userId, function(user) {...});
// или
$("#userPlace").load(user.show(userId));

    attr: function( elem, name, value, pass ) {
        // don't set attributes on text and comment nodes
        if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
            return undefined;
        }

        if ( pass && name in jQuery.attrFn ) {
            return jQuery(elem)[name](value);
        }

        var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
            // Whether we are setting (or getting)
            set = value !== undefined;

        // Try to normalize/fix the name
        name = notxml && jQuery.props[ name ] || name;

        // Only do all the following if this is a node (faster for style)
        if ( elem.nodeType === 1 ) {
            // These attributes require special treatment
            var special = rspecialurl.test( name );

            // Safari mis-reports the default selected property of an option
            // Accessing the parent's selectedIndex property fixes it
            if ( name === "selected" && !jQuery.support.optSelected ) {
                var parent = elem.parentNode;
                if ( parent ) {
                    parent.selectedIndex;
    
                    // Make sure that it also works with optgroups, see #5701
                    if ( parent.parentNode ) {
                        parent.parentNode.selectedIndex;
                    }
                }
            }

            // If applicable, access the attribute via the DOM 0 way
            if ( name in elem && notxml && !special ) {
                if ( set ) {
                    // We can't allow the type property to be changed (since it causes problems in IE)
                    if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
                        jQuery.error( "type property can't be changed" );
                    }

                    elem[ name ] = value;
                }

                // browsers index elements by id/name on forms, give priority to attributes.
                if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
                    return elem.getAttributeNode( name ).nodeValue;
                }

                // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
                // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
                if ( name === "tabIndex" ) {
                    var attributeNode = elem.getAttributeNode( "tabIndex" );

                    return attributeNode && attributeNode.specified ?
                        attributeNode.value :
                        rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
                            0 :
                            undefined;
                }

                return elem[ name ];
            }

            if ( !jQuery.support.style && notxml && name === "style" ) {
                if ( set ) {
                    elem.style.cssText = "" + value;
                }

                return elem.style.cssText;
            }

            if ( set ) {
                // convert the value to a string (all browsers do this but IE) see #1070
                elem.setAttribute( name, "" + value );
            }

            var attr = !jQuery.support.hrefNormalized && notxml && special ?
                    // Some attributes require a special call on IE
                    elem.getAttribute( name, 2 ) :
                    elem.getAttribute( name );

            // Non-existent attributes return null, we normalize to undefined
            return attr === null ? undefined : attr;
        }

        // elem is actually elem.style ... set the style
        // Using attr for specific style information is now deprecated. Use style instead.
        return jQuery.style( elem, name, value );
    }

[Record]
class A { A : int } // вот тут только засада, fieldsOf u [A = int] мы не умеем, хотя было бы здорово
public Index() : ActionResult
{
    def list = fun(title : string, x : IEnumerable[IA]) 
    {
        def    html = x.Select(x => render <# <li>${x.A}</li> #>); // тут похоже какая-то свертка, не хочу сейчас разбираться в языке, верну перечислением
        
        render <# 
          <h2>${title}</h2> 
            <ul>${String.Join(html.ToArray(), "\n")}</ul>
        #>;
    }
    using (def db = new Db())
    {
        def listT = list("T", db.T.Select(t => A(t.A)));
        def listV = list("V", db.V.Select(v => A(v.A)));
        
        render <#
            ${listT}
            ${listV}
            <br/>
             <form action="${Action.Ins}">Insert: ${Html.TextBox("A")} <input type="submit"/></form>
        #>;
    }
}

public Ins(a : string) : ActionResult
{
    using (def db = new Db())
    {
        db.T.Insert(() => new {A = a});
        RedirectTo(Action.Index());
    }
}

    def list = fun(title : string, x : IEnumerable[IA])
    {
        render <# 
            <h2>${title}</h2> 
            <ul>
                <li each="xx in x">${xx}</li>
            </ul>
        #>;
    }

    return <xml>
      <h2>{[title]}</h2>
      <ul>{xml}</ul>
    </xml>

        render <# 
          <h2>${title}</h2> //Тут у тебя уязвимость. Ибо ничто не говорит о том что title нужно эскейпить.
          <ul>${String.Join(html.ToArray(), "\n")}</ul>//Тут тоже все криво. String.Join и ToArray явно не к месту.
        #>;

        render <# 
          <h2>$title</h2> //title имеет тип string. Экейпим.
          <ul>..$html</ul>//html имеет тип list[HTML]. Все уже заэскейплено.
        #>;

fun counter n = return <xml><body>
  Current counter: {[n]}<br/>
  <a link={counter (n + 1)}>Increment</a><br/>
  <a link={counter (n - 1)}>Decrement</a>
</body></xml>

fun main () = counter 0

Z>Непонятен только бенефит слияния логики и отображения. Все то же самое можно делать со внешними вьюхами

WH>        render <# 
WH>          <h2>${title}</h2> //Тут у тебя уязвимость. Ибо ничто не говорит о том что title нужно эскейпить.
WH>          <ul>${String.Join(html.ToArray(), "\n")}</ul>//Тут тоже все криво. String.Join и ToArray явно не к месту. 
WH>        #>;
WH>

WH>fun counter n = return <xml><body>
WH>  Current counter: {[n]}<br/>
WH>  <a link={counter (n + 1)}>Increment</a><br/>
WH>  <a link={counter (n - 1)}>Decrement</a>
WH></body></xml>

WH>fun main () = counter 0
WH>

public Counter(int i) : ActionResult
{
  render <#
        Current counter: ${i}<br/>
    <a link="${Action.Counter(i + 1).Url}">Increment</a>        
        <!-- или так -->
        ${Action.Counter(i - 1).Link("Decrement")}
#>
}

Z>public Counter(int i) : ActionResult
Z>{
Z>  render <#
Z>        Current counter: ${i}<br/>
Z>    <a link="${Action.Counter(i + 1).Url}">Increment</a>        
Z>        <!-- или так -->
Z>        ${Action.Counter(i - 1).Link("Decrement")}
Z>#>
Z>}
Z>

    def list = fun(title : string, x : IEnumerable[IA])
    {
        render <# 
            <h2>${title}</h2> 
            <ul>
                <li each="xx in x">${xx}</li>
            </ul>
        #>;
    }

    def list = fun(title : string, x : IEnumerable[IA])
    {
        render <# 
            <h2>$title</h2> 
            <ul>
                ..$(render xx in x <# <li>${xx}</li> #>)
            </ul>
        #>;
    }

WH>                <li each="xx in x">${xx}</li>
WH>

WH>                ..$(render xx in x <# <li>${xx}</li> #>)
WH>

<table if="products.Any()">
  <tr each="p in products">
        <td>$!{p.Name}</td>
        <td>$!{p.Price}</td>
        <td>$!{p.Location}</td>
  </tr>
</table>  
<else>
  <p>No products found.
</else>

if (products.Any())
{
    render <#
        <table>
            $(render p in products<# 
                <tr>
                    <td>$(p.Name)</td>
                    <td>$(p.Price)</td>
                    <td>$(p.Location)</td>
                </tr>
            #>)
        </table>
    #>
}
else
    render <# <p> No products found. </p> #>

def renderProducts(products)
{
    def renderProduct(p)
    {
        render <#
            <tr>
                <td>$(p.Name)</td>
                <td>$(p.Price)</td>
                <td>$(p.Location)</td>
            </tr>
        #>
    }

    render <#
        <table>
            $(products.Map(renderProduct))
        </table>
    #>
}
if (products.Any())
    renderProducts(products);
else
    render <# <p> No products found. </p> #>

Z>Я что-то не помню где я отказался от серверного кода Ты про ASP.NET MVC что знаешь? На нем все это реализуется из коробки.

        public Index() : ActionResult {
            using (def db = Db())
            {
                ViewData["Message"] = $"NRails env: '$(db.Env)'. We have $(db.Persons.Count()) persons."; 
                ViewData["Taxonomies"] = db.Doctors.Select(d => d.Taxonomy).ToList();
            }
            
            View()
        }
// где
  [DatabaseManager]
  class Db: DbManager {}
  [Model]
    public class Doctor    {}

ВВ>>И казалось бы зачем мне шарповые рельсы? Мне вообще не нравится ASP.NET MVC, будь он хоть статический, хоть динамический.

x = 2
y = "str"
puts x + y

C:/temp/ruby.rb:ХХ:in `+': String can't be coerced into Fixnum (TypeError)