概要

traitの定義は以下のように行います。

trait TestTrait {
  requires testReq1;
  public test1( ...arg )->this.testReq1(arg[0]);
}
trait TestTrait2 {
  requires testReq2;
  public test1( ...arg )->this.testReq2(arg[0]);
  public test2->console.log('ok');
}
class MixinTest {
  public testReq1(arg) -> console.log(arg);
  public testReq2(arg) -> console.log(arg);
  mixin TestTrait with test1 as method1;
  mixin TestTrait2 without test1, with test2 as method2;
}

var TestTrait =  {
        _mochaTraitPrivate : {},
        _mochaTraitPublic :  {
          test1 : function testm1() {
            var arg = Runtime.toArray(arguments,0);
            this.testReq1(arg[0]);
          }
        },
        _mochaRequires :  {
          testReq1 : true
        },
        _mochaTraitMark : true
      },
      TestTrait2 =  {
        _mochaTraitPrivate : {},
        _mochaTraitPublic :  {
          test1 : function testm2() {
            var arg = Runtime.toArray(arguments,0);
            this.testReq2(arg[0]);
          },
          test2 : function testm3() {
            console.log('ok');
          }
        },
        _mochaRequires :  {
          testReq2 : true
        },
        _mochaTraitMark : true
      },
      MixinTest = function () {
        function constructor(){}
        function MixinTest() {
          Runtime.initializeClass(this,MixinTest,_mochaPrivateHolder,constructor,arguments,'MixinTest',101);
        }
        var _mochaPrivateHolder = function (){};
        Runtime.createUnenumProp(constructor,"__harmony_class__",1);
        MixinTest.prototype.testReq1 = function (arg) {
          return console.log(arg)
        };
        MixinTest.prototype.testReq2 = function (arg) {
          return console.log(arg)
        };
        Runtime.classMixin(MixinTest,_mochaPrivateHolder,TestTrait, {
          test1 : "method1"
        },{});
        Runtime.classMixin(MixinTest,_mochaPrivateHolder,TestTrait2,{
          test2 : "method2"
        }, {
          test1 : true
        });
        Runtime.checkRequirements(MixinTest,_mochaPrivateHolder,[TestTrait,TestTrait2],'class_test.js',105);
        Runtime.createUnenumProp(MixinTest.prototype,"constructor",constructor);
        return MixinTest;
   }()

詳細

クラスに対して振る舞いを注入します。traitはrequireプロパティを設定することで実装しなければならないメソッドを指定できます。 またmixin属性を設定することで、trait同士、あるいはclassとtraitを合成可能です。その際にmixin ... with <method_name> as <:new_name>とすることでメソッド名の書き換えが可能です。またwithout属性を指定することで、特定のメソッドのmixinを無効化することが可能です。 public,privateなどの指定はclassを参照してください。

インターフェース

trait <trait name>

traitを宣言します。

mixin <trait name> with(optional) <member name> as <new member name> without(optional) <member name>

traitをmixinします。もし同名のメンバがあった場合は上書きされます。with ~ asが指定されていた場合はmember nameをnew member nameでリネームします。without ~が指定されていた場合はそのメソッドはmixinされません。

概要

配列

var array = [0,1,2,3],
    [one,two,three,four] = array;
console.log(one,two,three,four);

変換後は以下のようになります。

var array = [0,1,2,3],
    one = array[0],
    two = array[1],
    three = array[2],
    four = array[3]

オブジェクト

var obj = {
      one : 0,
      two : 1,
      three : 2,
      four : 3
    },
    {one,two,three,four} = obj;

変換後は以下のようになります。

var obj = {
      one : 0,
      two : 1,
      three : 2,
      four : 3
    },
    one = obj.one,
    two = obj.two,
    three = obj.three,
    four = obj.four;

少々複雑な例

var object = {
      value1 : 100,
      value2 : {
        value3 : 100
      },
      value4 : [100,200,300],
      value5 : {
        value6 : [{value7 : 100}]
      },
      "@value" : {
        strvalue : 100
      }
    }
var {value1,value2:{ value3 },value4 : [ value5_,value6_,value7_ ],value5 : { value6 : [{value7}] },"@value":{strvalue}} = object;
		

変換後は以下のようになります。

var object = {
      value1 : 100,
      value2 : {
        value3 : 100
      },
      value4 : [100,200,300],
      value5 : {
        value6 : [{value7 : 100}]
      },
      "@value" : {
        strvalue : 100
      }
    },
    value1 = object.value1,
    value3 = object.value2 && object.value2.value3?object.value2.value3 : undefined,
    value5_ = object.value4 && object.value4[0]?object.value4[0] : undefined,
    value6_ = object.value4 && object.value4[1]?object.value4[1] : undefined,
    value7_ = object.value4 && object.value4[2]?object.value4[2] : undefined,
    value7 = object.value5 && object.value5.value6 && object.value5.value6[0] && object.value5.value6[0].value7?object.value5.value6[0].value7 : undefined,
    strvalue = object["@value"] && object["@value"].strvalue?object["@value"].strvalue : undefined;

概要

var obj = {a:1,b:2}
for each(var i in obj) {
  console.log(i);
}

変換後

var obj = {a:1,b:2}
for(var i in obj) {
  i = obj[i];
  console.log(i);
}

概要

var x = do { var t = f(); t * t + 1 };

変換後

var x = function () {
    var t = f();
    return t * t + 1;
}();

Detail

概要

無名関数

var a = (x,y,z) -> x + y + z,
b = (x,y,z) -> { return x + y + z; }

変換後は以下のようになります。

var a = function (x,y,z) { return x + y + z;},
b = function (x,y,z) { return x + y + z;}

関数宣言

foo(x,y,z) -> x + y + z;
bar(x,y,z) -> { return x + y + z; }

変換後は以下のようになります。

function foo (x,y,z) { return x + y + z;}
function bar (x,y,z) { return x + y + z;}

コンテキストの束縛

var a = (x,y,z) => x + y + z,
    b = (x,y,z) => { return x + y + z; }
foo(x,y,z) => console.log(this);
bar(x,y,z) => {console.log(this) }

変換後は以下のようになります。

var a = function (x,y,z) { return x + y + z; }.bind(this),
    b = function (x,y,z) { return x + y + z; }.bind(this);
function foo (x,y,z) { return console.log(_mochaLocalTmp0);}
foo = foo.bind(this);
function bar (x,y,z) { return console.log(_mochaLocalTmp1);}
bar = bar.bind(this);

概要

import module from './test';
import {exports1,exports2} from './test2'.module;
import [value1, value2] from './test3'.module.exports;
import exports from './test4'.module;
import './test5' as test5

変換後は以下のようになります。

var module = Runtime.modules.get('349045-test.js').module,
    _mochaLocalTmp0 = Runtime.modules.get('564059-test2.js').module,
    exports1 = _mochaLocalTmp0.exports1,
    exports2 = _mochaLocalTmp0.exports2,
    _mochaLocalTmp1 = Runtime.modules.get('906045-test3.js').module.exports,
    value1 = _mochaLocalTmp1[0],
    value2 = _mochaLocalTmp1[1],
    exports = Runtime.modules.get('945095-test4.js').module.exports,
    test5 = Runtime.modules.get('455905-test5.js');
    

詳細

importのルール

ファイルのインポートは以下のルールに沿って行われます。

概要

module testModule {
  export test() -> console.log('test!!');
}
module testModule2 {
  module testInnerModule3 {
    export testExport2()->2;
    export testExport3 = {test:200};
  }
}
module testModule3 = ->3

変換後は以下のようになります。

var testModule = Runtime.modules.get('3490394-test.js').testModule = function () {
      function testExport1() {
        return console.log('test!!');
      }
      var _mochaLocalExport = {};
      _mochaLocalExport.testExport1 = testExport1;
      return _mochaLocalExport;
    }();
var testModule2 = Runtime.modules.get('3490394-test.js').testModule2 = function () {
  var _mochaLocalExport = {},
    testInnerModule3 = _mochaLocalExport.testInnerModule3 = function () {
      function testExport2() {
        return 2;
      }
      var _mochaLocalExport = {};
      _mochaLocalExport.testExport2 = testExport2;
      var testExport3 = _mochaLocalExport.testExport3 =  {
          test : 200
        };
      return _mochaLocalExport;
    }();
  return _mochaLocalExport;
}();
Runtime.modules.get('3490394-test.js').testModule3 = function () {
  return 3;
}

詳細

各モジュールはファイルスコープ直下にしか置けません。モジュールに指定した名前が直接エクスポートされます。

宣言

module <module name> { ... }

moduleを宣言します。moduleはネスト可能です。ネストした場合は親のモジュール以下に設定されます。

module <module name> = <values>

直接値をエクスポートします。この構文でモジュールを宣言すると、'='で割り当てた値がmoduleの値になります。

概要

var foo = 200;
let (foo = 300) {
  console.assert(foo === 300);
}

変換後は以下のようになります。

var foo = 200;
!function(foo) {
  console.assert(foo === 300);
}(300);

詳細

スコープを生成します。let式の入り口に定義した値はlet式内のスコープでのみ有効になります。

概要

batch assignment operator

var namespaces = {
      foo : {},
      bar : {}
    }
namespaces.{
  baz : {}
}.{
  qux : {}
}

変換後は以下のようになります。

var namespaces = {
      foo : {},
      bar : {}
    }
Runtime.extend(Runtime.extend(namespaces, {
  bar : {}
}), {
  qux : {}
});

private property

var foo = 'private_name';
var namespaces = {
      [foo] : {},
      bar : {}
    }

変換後は以下のようになります。

var foo = 'private_name';
var namespace = {
      bar : {}
    }
Runtime.createUnenumProp(namespace, 'foo', {});

概要

tuple

var tuple = #[0,1,2,3];
var tuple2 = new Tuple(0,1,2,3);

record

var foo = #{"foo":0,"bar":1,"baz":2}
var bar = new Record({"foo":0,"bar":1,"baz":2});

概要

//通常のjavascript
function doCallback(num) {
  console.log(num + "\n");
}
function fib() {
  var i = 0, j = 1, n = 0;
  while (n < 10) {
    doCallback(i);
    var t = i;
    i = j;
    j += t;
    n++;
  }
}
fib();
//generatorを使用すると...
function fib() {
  var i = 0, j = 1;
  while (true) {
    yield i;
    var t = i;
    i = j;
    j += t;
  }
}
var g = fib();
for (var i = 0; i < 10; i++) {
  console.log(g.next() + "\n");
}

詳細

MDNからの引用

yield キーワードを含む関数がジェネレータです。これを呼ぶと、ジェネレータの仮引数は実引数と結び付きますが、本体は実際には評価されません。代わりにジェネレータ・イテレータが返ってきます。ジェネレータ・イテレータの next() メソッドを呼び出すたびに、繰り返しのアルゴリズムが 1 回ずつ実行されます。それぞれのステップでの値は、yield キーワードで指定された値です。yield をアルゴリズムの繰り返しの範囲を示すジェネレータ・イテレータ版の return だと考えましょう。毎回 next() を呼び出すたび、ジェネレータのコードは yield の次の文から再開します。 あなたはジェネレータ・イテレータを、その next() メソッドを繰り返し呼び出すことで、あなたが望んだ結果の状態にたどりつくまで反復させられます。この例では、私たちが欲しいだけの結果を手に入れるまで g.next() を呼び出し続けることで、私たちはどれだけでも多くのフィボナッチ数を得ることができます。

MDN Generator

簡単に説明すると関数をyieldキーワードの位置で一時停止し、二回目以降はその場所から実行を再開します。またnextだけではなく、yieldに対して、値を与えられるsendメソッドもあります。

MDN

一度 next() メソッドを呼び出してジェネレータをスタートさせると、与えた特定の値を最後の yield の結果として扱わせる send() を使うことができます。その際ジェネレータはその次の yield のオペランドを返します。 ジェネレータを勝手な時点から始めることはできません。特定の値を send() する前に必ず next() でジェネレータをスタートさせなければなりません。

MDN Generator

sendの例

yieldTest()-> {
  for ( var i = 0;i<10; i++ ) {
    var m = yield i;
    if ( m === true ) {
      yield i + 1;
    } else if ( m === false ){
      yield i - 1;
    } else {
      yield i;
    }
  }
}
generator = yieldTest();
@assert( true , generator.next() === 0 );
@assert( true , generator.send( true ) === 1 );
@assert( true , generator.send( false ) === 1 );
@assert( true , generator.send( true ) === 2 );
@assert( true , generator.send( false ) === 2 );
@assert( true , generator.send( true ) === 3 );
@assert( true , generator.send( true ) === 3 );
@assert( true , generator.send( true ) === 4 );
@assert( true , generator.send( false ) === 4 );
@assert( true , generator.send( true ) === 5 );

このようにsendに値を与えると、yield i の部分が引数に置き換わります。

iterator

var iter = {
      arr : [],
      add : function ( value ) {
        this.arr.push( value );
      },
      iterator : function () {
        var arr = this.arr;
        return {
          index : 0,
          next : function () {
            if ( arr.length > this.index ) {
              var ret = arr[ this.index ];
              this.index++;
              return ret;
            } else {
              throw StopIteration;
            }
          }
        }
      }
    }

詳細

この例のように、iteratorを生成するにはiteratorsモジュールのiteratorの値を、objectのプロパティにする必要があります。 ここで定義したiteratorはES Nextで追加されたfor of構文で使用されます。 詳しくはfor ofを参照してください。

generatorかiteratorの定義されたオブジェクトを与えることで、次々にnextを呼び出し、StopIterationが投げられると処理を終了します。