小编Hug*_*ugh的帖子

C++规范的哪一部分限制参数依赖查找在相关命名空间集合中查找函数模板？换句话说,为什么main下面的最后一次调用无法编译？

namespace ns {
    struct foo {};
    template<int i> void frob(foo const&) {}
    void non_template(foo const&) {}
}

int main() {
    ns::foo f;
    non_template(f); // This is fine.
    frob<0>(f); // This is not.
}

如果我有一个monad转换器类型采用两个类型参数,我可以liftM用来将值提升到转换后的monad:

scala> val o = 1.point[List].liftM[OptionT]
o: scalaz.OptionT[List,Int] = OptionT(List(Some(1)))

但是,如果我尝试相同的东西,EitherT似乎我必须使用类型别名(或类型lambda):

scala> val e = 1.point[List].liftM[({type l[a[+_],b] = EitherT[a, String, b]})#l]
e: scalaz.EitherT[List,java.lang.String,Int] = scalaz.EitherTFunctions$$anon$14@3f8905ca

这样做的正确方法是什么？理想情况下推断liftM使用表达式的预期类型(类似val blah: EitherT[List, String, Int] = 1.point[List].liftM)的类型参数.

我有一个包含两个子项目的项目.在其中一个,我想在另一个sbt-native-packager中使用sbt- docker.但是,它们都定义了dockerCmd具有不同类型(String和Seq[String]分别)的键,因此加载项目失败:

java.lang.RuntimeException: Some keys were defined with the same name but different types: 'dockerCmd' (scala.collection.Seq[java.lang.String], java.lang.String)

有没有办法解决这个问题比修改插件以便在类型上达成一致更容易？

我可以编写一个简单的递归多态函数:

object simpleRec extends Poly1 {
  implicit def caseInt = at[Int](identity)
  implicit def caseList[A, B](implicit ev: simpleRec.Case.Aux[A, B]) =
    at[List[A]](_.headOption.map(simpleRec))
}

这似乎很大程度上符合我的要求; 但是,我似乎得到了一个荒谬的结果类型:

scala> simpleRec(List.empty[List[Int]])
res3: Option[B] = None

scala> simpleRec(List(List(1)))
res4: Option[B] = Some(Some(1))

我怎么能让这给我价值Option[Option[Int]]而不是Option[B]？我希望我在这里犯了一些愚蠢的错误,但无法弄清楚它是什么.

使用Scalaz 7,我们可以获得monoids产品的零:

scala> mzero[(Int, String)]
res13: (Int, String) = (0,"")

是否有更简单的方法来获得其字段为幺半群的案例类的零值？理想情况下,不需要重复字段类型的方法:

scala> case class Foo(x: Int, y: String)
defined class Foo
scala> (Foo.apply _).tupled(mzero[(Int, String)])
res15: Foo = Foo(0,)

在Scala中,有很多方法可以创建对象:

例如,使用new关键字创建类

class Car {   
  def startEngine() = println("run....") 
}
val car = new Car 
car.startEngine()  // run....

其中car对象应该像堆中的Java座位中的"newed"对象一样,并且在被取消引用时等待垃圾收集.

那么,创造特质怎么样？

trait Car {
  def startEngine() = println("run...")
}
val car = new Car {}
car.startEngine() //run....

这是一个有效的语法,使用类myCar扩展Car创建对象.相反,它只是从Trait创建对象.

它是否反对堆中的座位？(我猜它不是)那么,它是否存在于堆栈中并且一旦从scoop中被取消引用为局部变量？

最后,如何通过对象？

object Car {
  def startEngine() = println("run...")
}
Car.startEngine()  //run....

这与via Trait相同吗？我相信对象更有可能生活在堆栈中.

在内存分配方面,有人可以就这三种语法之间的区别进行阐述吗？