小编Ral*_*lph的帖子

在Scala中,如果我创建了一个对象和伴随类,protected如果导入了对象,则可以从类中访问使用修饰符声明的标识符:

object Foo {
  protected val X = 42
}
class Foo {
  import Foo._
  def getX(): Int = X
}

但是,protected无法从类Foo的子类访问标识符:

class Bar extends Foo {
  import Foo._
  def getX(): Int = X * 2
}

我得到一个编译时错误Bar.

其他(隐含的)public,是否有任何访问修饰符,我可以X从它的伴侣的子类访问它,但不能从其他类,包括同一个包中的其他类访问？

为什么

(macroexpand '(.. arm getHand getFinger))

扩展到

(. (. arm getHand) getFinger)

而

(macroexpand '(-> arm getHand getFinger))

扩展到

(getFinger (clojure.core/-> arm getHand))

换句话说,为什么->第二个例子没有完全扩展呢？

我正在使用Clojure和RESTEasy设计JAX-RS REST服务器.

我的理解是,用Lisp族语言编写的应用程序比"传统"命令式语言中的应用程序更多地构建为"特定于域的语言".应用程序从下到上设计为越来越"精致"的功能,直到"顶层"应用程序成为对高级功能的一系列函数调用.

我试图为我的REST服务器执行此操作,从服务URL请求的资源类开始(GET,POST,PUT,DELETE).

这是我的第一个资源:

(ns com.example.server.resources.buildtime
  (:import [javax.ws.rs CookieParam GET Produces Path]
           [javax.ws.rs.core Context Cookie NewCookie Response UriInfo]
           [org.jboss.resteasy.annotations.providers.jaxb Formatted]))

(definterface BuildTime
  (getBuildTime [^javax.ws.rs.core.UriInfo info
                 ^javax.ws.rs.core.Cookie security-cookie]))

(deftype
  ^{Formatted true}
  BuildTimeResource []
  BuildTime
  (^{GET true
     Path "/buildtime"
     Produces ["application/json"]}
    getBuildTime
    [this info security-cookie]
    (.. (Response/ok "20111009") build)))

当使用GET http方法在URL"/ buildtime"调用时,此资源将服务器构建时间作为String(包含在JSON包中)返回.

我将编写更多这些资源类和封闭方法(大多数类将有多个方法),每个都有一个definterface和一个deftype.这似乎是宏的完美用法.

我正在征求关于如何以DSL方式完成这项工作的建议.如何根据DSL进行思考？

在Scala中,我有一个正则表达式模式匹配,如下所示:

val Regex = """(\d{4})/(\d{2})/(\d{2})""".r
val Regex(year, month, day) = "2013/01/06"

结果是:

year: String = 2013
month: String = 01
day: String = 06

如何在Haskell中完成类似的结果？换句话说,我可以匹配包含组的正则表达式并将组分配给标识符吗？

说我有三个数据库访问功能foo,bar以及baz可在每个返回Option[A],其中A一些模型类,并调用互相依赖.

我想按顺序调用函数,并且在每种情况下,如果找不到值,则返回相应的错误消息(None).

我当前的代码如下所示:

Input is a URL: /x/:xID/y/:yID/z/:zID

foo(xID) match {
  case None => Left(s"$xID is not a valid id")
  case Some(x) =>
    bar(yID) match {
      case None => Left(s"$yID is not a valid id")
      case Some(y) =>
        baz(zID) match {
          case None => Left(s"$zID is not a valid id")
          case Some(z) => Right(process(x, y, z))
        }
    }
}

可以看出,代码严重嵌套.

相反,我使用for理解,我不能给出具体的错误信息,因为我不知道哪一步失败了:

(for {
  x <- foo(xID) …

我有读取XML文件的代码.我需要处理的元素的一些属性是可选的.我正在尝试使用Option [T]来管理它们.我已经写了以下内容来pimp \Node运算符返回的NodeSeq类型:

class NodeSeqWrapper(nodeSeq: NodeSeq) {
  def textOption: Option[String] = {
    val text = nodeSeq.text
    if (text == null || text.length == 0) None else Some(text)
  }
}
implicit def nodeSeqWrapper(nodeSeq: NodeSeq): NodeSeqWrapper =
  new NodeSeqWrapper(nodeSeq)

然后像这样调用它:

(node \ "@attr").textOption.getOrElse("Some default value")

如果节点具有"attr"属性,则此代码获取其值.如果没有,则返回值"Some default value".

我怎样才能改善这个？有没有办法将类定义折叠到隐式方法中？有没有更好的方法来获取"可选"属性值？我使用Option[T]"正确"吗？

我有一个\x f -> f x正在foldM操作中使用的lambda ,其中x是一个值和f :: a -> b.

是否有内置功能可以做到这一点？

我可以更换吗？

foldM (\x f -> f x) ...

和一些 f'

foldM f' ...

我以为flip会这样做,但需要三个参数(flip :: (a -> b -> c) -> b -> a -> c)

它可能类似于|>F#.

我可能不太了解IO monad.

如果我编写一个预计运行数月的应用程序,同时记录其进度,那么IO monad会将所有日志信息保存在RAM中直到结束吗？

在IO Inside的博客中,Haskell将世界塑造为

main :: RealWorld -> ((), RealWorld)

这样在执行代码的Haskell部分期间不会发生IO,但只有在应用程序返回时才会发生main.

我可能完全误解了这一点.有人能解释时哈斯克尔实际上做IO？

以下函数f尝试Int使用IO (Maybe Int)函数两次读取两次,但在成功读取一次后执行"短路"执行Int:

readInt :: IO (Maybe Int)

f :: IO (Maybe Int)
f = do
  n1 <- readInt
  case n1 of
      Just n' -> return (Just n')
      Nothing -> do
        n2 <- readInt
        case n2 of
              Just n' -> return (Just n')
              Nothing -> return Nothing

有没有一种很好的方法来重构这段代码？如果我将它扩展到三次尝试,这将变得非常毛茸茸......

(我的思维过程:看到这个"staircasing"告诉我,也许我应该使用Monad的情况Maybe,但由于这是已经在IO单子,我将不得不使用MaybeT(),但我只需要？一个的readInt来成功,所以Maybemonad在第一次Nothing出错的行为在这里是错误的...)

我正在尝试将 a 转换HashSet<String>为一个排序向量，然后可以join用逗号进行编辑：

use std::collections::HashSet;

fn main() {
    let mut hs = HashSet::<String>::new();
    hs.insert(String::from("fee"));
    hs.insert(String::from("fie"));
    hs.insert(String::from("foo"));
    hs.insert(String::from("fum"));

    let mut v: Vec<&String> = hs.iter().collect();
    v.sort();

    println!("{}", v.join(", "));
}

这不会编译：

use std::collections::HashSet;

fn main() {
    let mut hs = HashSet::<String>::new();
    hs.insert(String::from("fee"));
    hs.insert(String::from("fie"));
    hs.insert(String::from("foo"));
    hs.insert(String::from("fum"));

    let mut v: Vec<&String> = hs.iter().collect();
    v.sort();

    println!("{}", v.join(", "));
}

我明白为什么我不能加入Vec<&String>，但我怎样才能将 转换HashSet为 a Vec<String>，以便它可以加入？

在 Rust 中打印由空格分隔的迭代器的惯用方法是什么？似乎并不适用，因为迭代器Args返回String值，不像迭代器HashSet返回&String …