小编Xia*_*ong的帖子

我有一个组件将显示字符串数组.代码看起来像这样.

React.createClass({
  render() {
     <div>
        this.props.data.map(t => <span>t</span>)
     </div>
  }
})

它工作得非常好.即如果props.data = ['tom','jason','chris'] 页面中的渲染结果将是tomjasonchris

然后,我想使用逗号加入所有名称,所以我将代码更改为

this.props.data.map(t => <span>t</span>).join(', ')

但是,渲染结果是[Object],[Object],[Object].

我不知道如何解释对象成为要呈现的反应组件.有什么建议吗？

我对traverse,traverseU和traverseM的使用案例感到困惑,我在scalaz网站上搜索了它,简单的代码示例:

 def sum(x: Int) = x + 1

 List(1,2,3).traverseU(sum)

看起来它类似于(地图和聚合):

List(1,2,3).map(sum).reduceLeft(_ + _)

我认为它不仅仅是针对traverseU,我只是想知道这三种方法之间有什么区别,我会有更好的示例代码来显示差异

提前谢谢了

最近,我一直在玩scalaz.iteratee和Play的iteratee.我认为iteratee是一个很好的想法,提供模块化而不是旧的命令循环 - 目的是使用一个函数作为每个新行的处理程序,而不是从文件中获取字符串[].

但是,当我查看scalaz.stream的功能概述时,它提到它的设计是取代旧的iteratee实现,但它没有提到为什么要替换它.

有人可以向我解释我们是否可以使用Stream,我们可以获得哪些功能和优点以及使用iteratee有什么缺点？

我想测试一个使用一个第三个lib来获取数据的JS,所以我使用jest mock来实现.当我在测试中直接调用它时,它正在工作.但是,它在源代码中使用时不起作用.

这是代码

//Source implementation

var reference = require('./reference');

module.exports = {
  getResult: function() {
    return reference.result();
  }
};


//Test code

jest.dontMock('./foo');
jest.dontMock('console');

describe('descirbe', function() {
  var foo = require('./foo');

  it('should ', function() {
    var reference = require('./reference');

    reference.result.mockImplementation(function (a, b, c) {
      return '123'
    });

    console.log(foo.getResult()); // undefined
    console.log(reference.result()); // 123
  });

});

我想明白之间的差别asyncBoundary和mapAsync.从一目了然,我猜他们应该是一样的.但是,当我运行代码时,它看起来asyncBoundary比性能更快mapAsync

这是代码

implicit val system = ActorSystem("sourceDemo")
implicit val materializer = ActorMaterializer()


Source(1 to 100).mapAsync(100)(t => Future {t + 1}).mapAsync(100)(t => Future {t * 2}).map(println).to(Sink.ignore).run()
Source(1 to 100).map(_ + 1).withAttributes(Attributes.asyncBoundary).map(_ * 2).map(t => println("async boundary", t)).to(Sink.ignore).run()

该输出:异步边界总是比mayAsync完成更快.

从描述asyncBoundary(https://doc.akka.io/docs/akka-stream-and-http-experimental/current/scala/stream-flows-and-basics.html)的文档中,我看到它正在运行在不同的CPU上,但mapAsync是使用Future的多线程.未来也是异步的.

请问有关这两个API的更多说明吗？

我对无形特征概述中显示的示例感到困惑.

object size extends Poly1 {
  implicit def caseInt = at[Int](x => 1)
  implicit def caseString = at[String](_.length)
  implicit def caseTuple[T, U]
    (implicit st : Case.Aux[T, Int], su : Case.Aux[U, Int]) =
      at[(T, U)](t => size(t._1)+size(t._2))
}

scala> size(((23, "foo"), 13))
res7: Int = 5

1. 什么是Case.Aux？
2. 为什么参数化类型是Int not String
3. 如果size(((23,"foo",123),13)),如何定义CaseTuple？

提前谢谢了

Semigroup的目的是确保关联性和闭合性monoid的目标是基于Semigroup并提供额外的身份.当我使用| + | semigroup appender,为什么我定义了隐式monoid而不是隐式半群

这是我使用reduceLeft的代码,它不需要初始值

    val result1 = List(Staff("John", 36), Staff("Andrew", 30))
    val result2 = List(Staff("John", 40), Staff("Danny", 30))
    val result3 = List(Staff("Andrew", 30))
    val result4: List[Staff] = List()

    implicit val staffListSemigroup = new Monoid[List[Staff]] {

      override def zero: List[Staff] = Nil

      override def append(f1: List[Staff], f2: => List[Staff]): List[Staff] = {

        val mapSemigroup = f1.map(t => (t.name, t.numberOfTasks)).toMap |+| f2.map(t => (t.name, t.numberOfTasks)).toMap

        mapSemigroup.map(t => Staff(t._1, t._2)).toList

      }
    }

    val result = List(result1, result2, result3, result4).reduceLeft(_ |+| _) …

我知道Scala只能混合特性,它对依赖注入和蛋糕模式有意义.我的问题是为什么我仍然可以声明一个需要另一个"类"而不是特性的类.

码:

class C
class D { self : C =>}

这仍然是成功的.我认为它应该编译失败,因为在这一点上新的实例D(C是类不是特征)怎么样.

编辑:

当试图实例化D时:

新的D与C //编译失败C类需要成为混合的特征.

我有这个代码

"123".getClass.asInstanceOf[Class[String]]
"123".getClass.asInstanceOf[classOf[String]]//compilation error, classOf not defined

但是,我可以这样使用classOf

println(classOf[String])

我在这里有点困惑,classOf [T]和Class [T]之间有什么区别

提前谢谢了

这是将请求参数绑定到路由器的代码.

val testReader: Endpoint[Test] = Endpoint.derive[Test].fromParams
val test: Endpoint[String] = post("test" ? testReader) { t : Test => {
    Created("OK")
  }}

我正在使用这种方法fromParams.此方法可以非常酷的方式绑定请求参数.但是,我不知道哪种类似的方式可以绑定雀科中的请求体

提前谢谢了