小编Dan*_*hin的帖子

当unnesting 数组结果返回FROMsub-时，我遇到了一个相当不直观的行为SELECT。

SELECT unnest(c).* 
FROM (SELECT chat_messages[0 : array_length(chat_messages, 1)] 
      FROM Chats WHERE chat_id = 2) c

这是我最初的查询。Postgres 不喜欢它：

函数 unnest(record) 不存在

但是这个看似等效的查询有效：

SELECT * 
FROM unnest((SELECT chat_messages[0 : array_length(chat_messages, 1)] 
             FROM Chats WHERE chat_id = 2)) c

此查询对相同的错误消息不起作用：

SELECT * 
FROM (SELECT chat_messages[0 : array_length(chat_messages, 1)] 
      FROM Chats WHERE chat_id = 2) c,
     unnest(c) u

我很确定我在这里遗漏了一些东西。为什么会有这样的行为？record当定义复合类型时，子查询如何返回类型？

考虑以下:

trait Foo {
  type F[_]
  type A
  type FA = F[A]
  def get: FA
}

class SeqStringFoo extends Foo {
  type F[_] = Seq[_]
  type A = String
  def get: Seq[String] = Seq("hello world")
}

def exec[F <: Foo](foo: F): F#FA = foo.get

val seq1: Seq[Any] = exec(new SeqStringFoo()) // Seq[Any] = List(hello world)
val seq2: Seq[String] = exec(new SeqStringFoo()) // Error: Expression SeqIntFoo#FA doesn't conform to Seq[String]

seq2因为某些原因,String在使用类型投影 时,包装类型的类型信息会丢失F#FA.

当返回的类型不是更高级的类型时,这不会发生. …

什么是对范围routes的文件找implicit好像PathBindable还是QueryStringBindable？

对于自定义类型,只需在伴随对象中定义它们就像下面这样简单:

case class Foo(data: String)
object Foo {
  implicit val pathBinder: PathBindable[Foo] = ???
}

但是,对于现有类型,routes由于我们不能import在此处执行任何自定义,因此不清楚在文件中声明隐式的位置.

那么,路由文件的含义范围是什么？

我正在尝试抽象一些可以返回任何类型的库API A,Option[A]或者Seq[A].

到目前为止,我有这样的事情:

  type Const[T] = T

  sealed abstract class Request[F[_], A]

  case class GetOne(id: Int) extends Request[Const, Int]
  case class GetMany() extends Request[Seq, String]

然后当我使用它时:

def get[F[_], A](request: Request[F, A]): F[A] = request match {
  case GetOne(id) => client.getOne[F[A]](id)
  case GetMany() => client.getMany[A]() // error: Seq[A] does not conform to F[A]
}

我理解为什么这不会起作用,因为F[_]它不是那种类的子类covariant Seq[_].但我不知道如何在能够使用的同时解决这个问题Const[A].我绝望了吗？请帮忙.

我试图Traversable通过pimping via 添加一些特征方法implicit class.

但我有点失去了CanBuildFrom特质.考虑以下:

implicit class TraversableExt[+A, +Repr <: Traversable[A]](traversable: Repr) {
  def debug[That](name: String)(implicit bf: CanBuildFrom[Repr, A, That]): That =
    traversable.map{ a => println(name + ": " + a); a }(bf)
}

这失败了,错误:

错误:(21,59)类型不匹配;
发现:scala.collection.generic.CanBuildFrom [Repr,A,That]
required:scala.collection.generic.CanBuildFrom [Traversable [A],A,That]
traversable.map {a => println(name +":"+一个); a}(bf)^

我猜测因为Reprin CanBuildFrom[-Repr, -Elem, +To]是逆变的,因此我Repr的上限Traversable[A]可能不起作用.

但总的来说,我很失落.有人可以帮忙吗？

所以新的ECMAScript 6引入了for .. of循环语法.

不幸的是,没有很多文件可以解释这是什么.与它如何与使用Array.prototype.forEach或for .. in循环不同.

这只是另一种必要的执行方式Array.prototype.forEach吗？

我已经在这里阅读过Mozilla的文档.但这个想法对我来说太模糊了.

有人关心向这个半智人解释一下吗？

我最近开始深入研究MVVM架构模式.我已经理解了它的大部分内容,但仍然很少有人怀疑ViewModel应该代表View承担多少责任.

换句话说,View应该是多么愚蠢？

例如,对于简单的状态协调,例如TextView在用户按下后清除SubmitButton.这种状态协调只需要使用一些流行的数据绑定框架来实现.

例如,在伪ReactiveCocoa中:

textView.text <~ submitButton.pressed.map { _ in "" }

然而,Martin Fowler在他的演示模型中写道,

表示模型包含的逻辑表明,只有选中复选框才能启用composer字段,因此当视图从Presentation Model更新自身时,composer字段控件会更改其启用状态

这表明即使是TextView按下后清除的简单逻辑Button也应封装在内部ViewModel.

这样的设计选择导致类似这样的事情(再次,在伪ReactiveCocoa中):

// In View
viewModel.submitButtonPressed <~ submitButton.pressed
textView.text <~ viewModel.textViewText

// In ViewModel
textViewText <~ viewModel.submitButtonPressed.map { _ in "" }

虽然它会导致逻辑的更好的封装,同时假设观点仅为结合工作(使其哑),它确实使代码更大量冗长,导致之间更紧密的耦合View,并ViewModel(通过要求ViewModel要注意的SubmitButton).

我一般都是MVVM模式的新手,每天都在学习东西.

ViewModel需要承担多少责任？

换句话说,必须View完全愚蠢并且只处理简单绑定(将其UI元素连接到由其提供的可绑定属性ViewModel)或者是否可以View处理如上所述的相当简单的逻辑？

另一方面,MVVM 之间的紧密耦合View和ViewModel 好吗 …

我不确定问题标题的措辞是否恰当,所以我会详细说明.

sealed trait RedisKey[A] {
  type valueType = A
  def name: String
}
case object FirstName extends RedisKey[String] { val name = "first_name" }
case object Age extends RedisKey[Int] { val name = "age" }

trait Redis {
  def fetch(key: RedisKey)// : key.valueType
}

我需要限制的返回类型fetch的RedisKey的依赖型 valueType(不知道这是正确的术语).但很明显,上面不会工作,因为我需要一个具体的实例,RedisKey然后才能访问它的依赖类型.

是否有可能以任何方式实现这一目标？