module JSON where
foreign import unsafeParse :: forall a. String -> a"use strict"
// module JSON
exports.unsafeParse = function( json ) {
return JSON.parse(json);
}psci> type Foo = { a :: String, b :: Int }
psci> let o = unsafeParse "{\"a\": \"foo\", \"b\": 123 }" :: Foo
psci> print o.a
"foo"
{
"firstName": "James",
"lastName": "Maxwell"
}
trait Person {
val firstName: String
val lastName: String
}
@js.native
trait Person extends js.Object {
val firstName: String = js.native
val lastName: String = js.native
}
val json = """
{
"firstName": "James",
"lastName": "Maxwell"
}
"""
val obj = JSON.parse( json )
val person = obj.asInstanceOf[Person]
println(s"Hello, ${person.firstName} ${person.lastName}")
実行結果
$> Hello, James Maxwell
1 |
1 2 | val result: Future[Int] = enum.run( iteratee ) |
1 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | val (enum, channel) = Concurrent.broadcast[Int] // Iteratorを実行 val result = enum.run( Iteratee.fold[Int, Int](0) { (sum, x) => sum + x }) // Enumeratorに入力を与える channel.push( Input.El(1) ) channel.push( Input.El(2) ) channel.push( Input.El(3) ) channel.push( Input.El(4) ) // 入力終わり channel.end // 10が出力される println( Await.result( result, 5.second ) ) |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | val enum = Concurrent.unicast[Int] { channel => // Enumeratorに入力を与える channel.push( Input.El(1) ) channel.push( Input.El(2) ) channel.push( Input.El(3) ) channel.push( Input.El(4) ) channel.end } // Iteratorを実行 val result = enum.run( Iteratee.fold[Int, Int](0) { (sum, x) => sum + x }) // 10が出力される println( Await.result( result, 5.second ) ) |
1 |
1 2 3 4 5 | def fold( folder: .. ) = { def func = <入力を受け取り、それを処理する関数> folder( func ) } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | class MyIteratee extends Iteratee[Int, Int] { def fold[B]( folder: Step[Int, Int] => Future[B] )( implicit ec: ExecutionContext ): Future[B] = { // funcの実装 // 入力を受け取り、次のIterateeを返す def func( input: Input[Int] ): Iteratee[Int, Int] = input match { case Input.El( e ) => println( e ) new MyIteratee // とりあえず、他の入力は無視する case _ => ??? } // funcをStep.Contに包んで渡す folder(Step.Cont(func _)) } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | // folder関数は、Iterateeに入力を与える役割を担う。 // 引数のstepは、Iterateeから受け取る。MyIterateeでは、Step.Contを渡している。 def folder( step: Step[Int, Int] ): Future[String] = step match { // Step.Contからfuncを取り出す。 // funcというのは、MyIterateeで定義した入力を受け取って処理する関数。 case Step.Cont( func ) => // funcに入力(Input.El(1))を渡す // funcは新たなMyItrateeを返すが、ここでは無視する。 val next = func( Input.El(1) ) // "done"という文字列を返して終了 Future("done") // とりあえず他のStepは無視する case _ => ??? } |
1 2 3 4 | val result = (new MyIteratee).fold( folder ) // '1'と'done'が出力される println( Await.result(result, 5.second) ) |
1 2 3 4 5 6 7 | // Step.Doneは計算結果が必要なので、コンストラクタで計算結果を受け取る。 class DoneIteratee( sum: Int, input: Input[Int] ) extends Iteratee[Int, Int] { def fold[B]( folder: Step[Int, Int] => Future[B] )( implicit ec: ExecutionContext ): Future[B] = { folder(Step.Done(sum, input)) } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | // 前のIterateeの結果をコンストラクタで受け取る。 class MyIteratee( sum: Int ) extends Iteratee[Int, Int] { def fold[B]( folder: Step[Int, Int] => Future[B] )( implicit ec: ExecutionContext ): Future[B] = { // funcの実装 def func( input: Input[Int] ): Iteratee[Int, Int] = input match { case Input.El( e ) => // 入力が１０以下の場合は、前の結果と入力を足して、 // 次のIterateeに渡す if( e <= 10 ) new MyIteratee( sum + e ) // 入力が１０を超えた場合は、終了する。 // DoneIterateeがStep.Doneをfolderに渡す。 else new DoneIteratee( sum, input ) case _ => ??? } // funcをStep.Contに包んで渡す folder(Step.Cont(func _)) } } |
1 |
1 2 | else new DoneIteratee( sum, input ) |
1 2 3 4 5 6 7 8 9 10 | case Step.Cont( func ) => // Iterateeに入力を渡して、次に実行するIterateeを受け取る。 val next = func( Input.El( n ) ) // 入力を１つ増加して、次のIterateeを実行する。 next.fold( folder( n + 1 ) ) // Doneを受け取ったら、入力をやめて結果を返す。 case Step.Done( sum, _ ) => Future( sum ) case _ => ??? } |
1 2 3 | // 55が出力される println( Await.result(result, 5.second) ) |
1 2 3 4 5 6 7 8 9 10 11 12 | class MyIteratee( sum: Int ) extends Iteratee[Int, Int] { def fold[B]( folder: Step[Int, Int] => Future[B] )( implicit ec: ExecutionContext ): Future[B] = { def func( input: Input[Int] ): Iteratee[Int, Int] = input match { case Input.El( e ) => new MyIteratee( sum + e ) // この部分を追加 case Input.EOF => new DoneIteratee( sum, Input.EOF ) case _ => ??? } folder(Step.Cont(func _)) } } |
1 2 3 4 5 6 7 8 9 | case Step.Cont( func ) => // 入力が10を超えたらInput.EOFを返すように変更 val input = if( n <= 10 ) Input.El( n ) else Input.EOF val next = func( input ) next.fold( folder( n + 1 ) ) case Step.Done( sum, _ ) => Future( sum ) case _ => ??? } |
1 2 3 | // 55が出力される println( Await.result(result, 5.second) ) |
1 2 3 4 5 6 7 8 9 10 11 12 | class MyIteratee[A]( sum: A, f: (A, A) => A ) extends Iteratee[A, A] { def fold[B]( folder: Step[A, A] => Future[B] )( implicit ec: ExecutionContext ): Future[B] = { def func( input: Input[A] ): Iteratee[A, A] = input match { // sum + e を f(sum, e)に変更 case Input.El( e ) => new MyIteratee( f(sum, e), f ) case Input.EOF => new DoneIteratee( sum, Input.EOF ) case _ => ??? } folder(Step.Cont(func _)) } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | def folder[A]( xs: Seq[A] )( step: Step[A, A] ): Future[A] = step match { case Step.Cont( func ) => // シーケンスの先頭と残りの要素を抽出する val (input, tail) = if( xs.nonEmpty ) (Input.El( xs.head ), xs.tail) else (Input.EOF, Nil) // 先頭の要素をIterateeに渡す val next = func( input ) // 残りの要素を次のIterateeに渡す next.fold( folder( tail ) ) case Step.Done( sum, _ ) => Future( sum ) case _ => ??? } |
1 2 3 4 5 6 | val iteratee = new MyIteratee[Int](0, (sum, x) => sum + x) // 1から１０までのシーケンスを生成して、Itarateeに渡す val result = iteratee.fold( folder(1 to 10) ) // 55が出力される println( Await.result(result, 5.second) ) |
1 2 3 4 5 6 7 8 | val iteratee = Iteratee.fold[Int, Int](0) { (sum, x) => sum + x } // 1から１０までを順次入力するEnumerator(folder関数のようなものを生成) val enum = Enumerator.enumerate(1 to 10) // 実行 val result = enum.run( iteratee ) // 55が出力される println( Await.result(result, 5.second) ) |