s-panferov

var webpack = require('webpack');
var path = require("path");

module.exports = {

  entry: {
    app: './src/app/app.ts',
    vendor: [
      "jquery",
      "jquery-mockjax",

s-panferov

var x = 5;
var y = 10;

with({x: 20}) {
	var x = 30; 
    var y = 30;
	
	console.log(x);
    console.log(y);
};

s-panferov

state = rx.BehaviorSubject<
    model_state.ModelState<
        immutable.Map<
            Ref,
            rx.BehaviorSubject<model_state.ModelState<Model, void>>
        >,
        Meta
    >
>;

s-panferov

export interface ModelState<Model> {
    model: opty.Option<Model>;
    isProcessing: boolean;
    isPending: boolean;
}

export interface ListModel<Ref, Model, Meta> {
    models: immutable.Map<Ref, rx.BehaviorSubject<ModelState>>;
    meta: opty.Option<Meta>;
}

s-panferov

private dispatchLoadOrgs(action: org_actions.LoadOrgs.Start) {
    loadOrgsLock.lock(action.actionId, api.requestManager);

    org_api.OrgApi
        .loadOrgs(action.actionId)
        .then((reply) => {
            loadOrgsLock.unlock();
            this.dispatcher.dispatch(new org_actions.LoadOrgs.Complete(action, reply.orgs))
        })
        .catch((e) => {

s-panferov

var viewClass = bemr.block("card");

return DOM.div({className: viewClass},
    DOM.div({className: viewClass.el("cover")},
        avatar.AvatarF({
            url: "/public/profile.png",
            variant: avatar.Variant.Large,
            className: viewClass.el("avatar")
        }),
        DOM.div({className: viewClass.el("name")}, user.name)

s-panferov

var convertSM = require('convert-source-map');
var fs = require('fs');
var rewrite = require('connect-modrewrite');

module.exports = function (grunt) {

  grunt.registerTask('tsmap',  function() {
    var existingMap;
    var fileName = process.cwd() + '/dist/app.js';
    var fileContent = fs.readFileSync(fileName).toString();

s-panferov

Hi all, can somebody help me to rewrite this piece of code with new unboxed closures:

struct Builder;
pub fn build(rules: |params: &mut Builder|) -> Builder {
    let mut builder = Builder::new();
    rules(&mut builder);

    builder
}

s-panferov

interface Option<T> {
    map <U>(fn: (a: T) => U): Option<U>;
    isSome(): boolean;
    isNone(): boolean;
    isSomeAnd(fn: (a: T) => boolean): boolean;
    isNoneAnd(fn: () => boolean): boolean;
    unwrap(): T;
    unwrapOr(def: T): T;
    unwrapOrElse(f: () => T): T;
    map<U>(f: (a: T) => U): Option<U>;

s-panferov

module classes {

    export interface ClassManager {
        mod(...name: string[]): ClassManager;
        cmod(condition: boolean, ...name: string[]): ClassManager;
        toString(): string;
        before(...other: ToString[]): ClassManager;
        after(...other: ToString[]): ClassManager;
    }