小编acj*_*jay的帖子

我不确定这是否是最好的论坛,因为它本身并不是一个编程问题,但是这里有.

我是iOS应用程序的开发人员,我们将设计外包给第三方.他们向我们提供了一个巨大的PhotoShop文件,其中包含在单个图层上完成的所有单件作品,双重分辨率.为了将图稿放入XCode,我的工作流程如下:

1. 仅显示包含特定艺术作品单元的图层
2. 全选
3. 复制合并
4. 创建新图像(幸运的是,尺寸会自动处理)
5. 糊
6. 取消选择粘贴的图层并删除背景,以保持透明度
7. 将图像另存为x.psd
8. 将副本保存为x@2x.png
9. 将图像大小设置为原始尺寸的50%
10. 将副本另存为x.png
11. 放弃更改

这个应用程序非常大,因此对每个小图像执行此过程都非常繁琐.我不是很精通Photoshop,所以我想知道是否有更好的方法.在我看来,将步骤3-11组合成一个宏或脚本或其他东西应该很容易.在这些步骤的每次迭代中唯一改变的是输出名称.有什么建议？

我正在研究Django中的一个大型社交网络应用程序,我期望多次使用某些前端组件,并且通常设计的功能使自定义组件包含其他自定义组件,这些组件可能包含更小的子组件(广告无限).所有这些组件通常是动态生成的.我正在尝试找出在Django框架中构建它的最佳方法,这样我的组件易于维护并具有清晰的编程接口.严重依赖全局上下文似乎与此相反,但是,我可以看到通过在视图中一次完成所有操作来避免冗余查询的优势.

自定义包含模板标签似乎非常适合实现组件,但我想知道,高度嵌套的模板标签是否会产生性能问题,或者解析架构是否会阻止这种情况？在视图级别使其自我记录以呈现主页面模板,自定义标签和所有内容所需的上下文的最佳方法是什么？我想象一下,尝试正确维护代码来设置模板上下文是一个小小的噩梦.最后,维护这些组件的CSS的最佳方法是什么？

随意建议其他建议的方法来创建嵌套组件设计.

我认识一个之间的区别Monad,并Applicative是flatMap可用的Monad,但不是Applicative.

如果这是真的,我对这些Scala Play JSON 文档感到困惑:

所以有趣的是JsResult [A]是一个monadic结构,可以用于这种结构的经典函数:

flatMap [X](f:A => JsResult [X]):JsResult [X]

等等

但是,然后文件继续说:

请注意,JsResult [A]不仅仅是Monadic而且是Applicative,因为它累积了错误.这个累积的特性使得JsResult [T]使得用于理解不是很好,因为你只会得到第一个错误,而不是全部错误.

因为,据我所知,一个for-comprehension是语法糖flatMap,怎么可能JsResult是Applicative和Monad？

这是我的搜索对象:

package models.helper
import play.api.libs.json.Format
import play.api.libs.json.JsValue
import play.api.libs.json.JsObject
import play.api.libs.json.JsString

case class Search (name: String, `type`:String){

  implicit object SearchFormat extends Format[Search] {
    def reads(json: JsValue): Search = Search(
      (json \ "name").as[String],
      (json \ "type").as[String]
    )

    def writes(s: Search): JsValue = JsObject(Seq(
        "name" -> JsString(s.name),
        "type" -> JsString(s.`type`)
    ))  
  }
}

我在尝试使用WS调用web服务时尝试使用此类:

val search = response.json.as[Search]

但scala编译器一直在抱怨这条线:

找不到类型models.helper.Search的Json反序列化器.尝试为此类型实现隐式读取或格式.

谁能告诉我我做错了什么？

• 从https://sites.google.com/site/play20zh/scala-developers/working-with-json获取示例
• 这个帖子讨论了同样的问题,但没有提供解决方案,在什么网站上有什么示例 https://groups.google.com/forum/?fromgroups#!topic/play-framework/WTZrmQi5XxY

我知道复杂性是O(nlog(n)).但为什么？你是如何得出这个答案的？

任何帮助将不胜感激,我很有兴趣知道!

我一直在审查一些动态编程问题,而且我很难绕过一些代码来寻找最小数量的硬币来进行更改.

假设我们有25,10和1的硬币,我们正在进行30次更改.贪婪将返回25和5(1),而最佳解决方案将返回3(10).以下是本书中有关此问题的代码:

def dpMakeChange(coinValueList,change,minCoins):
   for cents in range(change+1):
      coinCount = cents
      for j in [c for c in coinValueList if c <= cents]:
            if minCoins[cents-j] + 1 < coinCount:
               coinCount = minCoins[cents-j]+1
      minCoins[cents] = coinCount
   return minCoins[change]

如果有人能帮助我绕过这段代码(第4行是我开始感到困惑的地方),那就太好了.谢谢!

我有一个示例代码如下.

import play.api.libs.json._
import play.api.libs.functional.syntax._
import play.api.data.validation.ValidationError
import play.api.libs.json.Reads._

case class Retailer(firstName:String,lastName:String,email:String,mobileNo:String,password:String)
case class Business(name:String,preferredUrl:String,businessPhone:String,retailer:Retailer)

object JsonTest {
  val jsonValue = """
  {
    "business":
    {
      "name":"Some Business Name",
      "preferredUrl":"someurl",
      "businessPhone":"somenumber",
      "retailer":
      {
        "firstName":"Some",
        "lastName":"One",
        "email":"someone@somewhere.com",
        "mobileNo":"someothernumber",
        "password":"$^^HFKH*"
      }
    }

  }
  """
  def printJson ={

    implicit val rltRds = (
      (__ \ "firstName").read[String] ~
      (__ \ "lastName").read[String] ~
      (__ \ "email").read[String] ~
      (__ \ "mobileNo").read[String] ~
      (__ \ "password").read[String]
    )(Retailer)    

    implicit val bsnsRds = (
      (__ \ "name").read[String] ~
      (__ \ …

不确定这是一个错误,但以下演示在最终案例中失败:

import spray.json._
import DefaultJsonProtocol._

object SprayTest {
  1.toJson
  "".toJson
  (Left(1): Either[Int, String]).toJson
  (Right(""): Either[Int, String]).toJson
  Seq(1).toJson
  Seq("").toJson
  Seq(Left(1), Right("")).toJson
  Seq(Left(1), Right("")).toJson(seqFormat(eitherFormat(IntJsonFormat, StringJsonFormat)))
}

所以所有的构建块似乎都有效,但是格式的组成Seq和Either失败,即使我尝试用勺子喂它.

我看到以下错误:

[error] SprayTest.scala:11: Cannot find JsonWriter or JsonFormat type class for Seq[Product with Serializable with scala.util.Either[Int,String]]
[error]   Seq(Left(1), Right("")).toJson
[error]                           ^
[error] SprayTest.scala:12: type mismatch;
[error]  found   : spray.json.DefaultJsonProtocol.JF[Either[Int,String]]
[error]     (which expands to)  spray.json.JsonFormat[Either[Int,String]]
[error]  required: spray.json.JsonFormat[Product with Serializable with scala.util.Either[Int,String]]
[error] Note: Either[Int,String] >: Product with Serializable with scala.util.Either[Int,String] (and …

是否可以从内在特质mixin中访问外部特征中的值？即:

trait Outer {
  val foo
  trait Inner
}

trait InnerMixin { this: Outer#Inner =>
  def bar {
    // how can I access 'foo' here? smth like Outer.this.foo
  }
}

谢谢

我在Play 2.3中有以下JSON阅读器:

import play.api.libs.json._
import play.api.libs.json.Reads._
val airportSearchReads: Reads[String] = (JsPath \ "search").read[String](minLength(3))

并且编译器给了我错误

diverging implicit expansion for type play.api.libs.json.Reads[M]
starting with method ArrayReads in trait DefaultReads

如果我使用implicit val我得到的

 ambiguous implicit values:
 both value uuidReads in trait DefaultReads of type => play.api.libs.json.Reads[java.util.UUID]
 and value airportSearchReads in object AirportSearch of type => play.api.libs.json.Reads[String]
 match expected type play.api.libs.json.Reads[M]

我如何让它工作？