小编mar*_*iop的帖子

我在一些项目中使用了函数循环,今天我发现它不是一个完整的函数,如GHCI示例所示:

?> Data.List.cycle []
*** Exception: Prelude.cycle: empty list

我知道,Haskells尝试使用总功能(除了基本功能head和tail),我不完全知道为什么cycle是不是其中之一.在我看来,cycle空列表的空列表是空的,我没有看到这个问题.为什么cycle空列表会抛出错误？

编辑:基于第一个答案,我认为我的想法并不完全清楚:我不想cycle []成为一个永无止境的计算.相反,我认为cycle []应该是:

cycle :: [a] -> [a]
cycle [] = []
cycle xs = xs ++ cycle xs

这[]是cycle []因为所有操作都完全正如我所做的那样.例如,take 3 []是[],因而take 3 (cycle [])可能[].这个解决方案有什么问题？

我想在Scala中读取一个CSV字符串/文件,以便给定一个case类C和一个错误类型Error,解析器填充一个Iterable[Either[Error,C]].是否有任何库可以执行此操作或类似的操作？

例如,给定一个类和错误

case class Person(name: String, age: Int)

type Error = String

和CSV字符串

Foo,19
Ro
Bar,24

解析器会输出

Stream(Right(Person("Foo",1)), Left("Cannot read 'Ro'"), Right(Person("Bar", 24)))

更新:

我认为我的问题不明确,所以让我澄清一下:有没有办法在Scala中读取CSV而不定义样板？鉴于任何案例类,有没有办法自动加载它？我想以这种方式使用它:

val iter = csvParserFor[Person].parseLines(lines)

我有一个ghci的问题,我需要一个如何调试它的建议.问题是,当我从导入的项目执行一个函数时,我有一个重复的定义错误,并且ghci退出,因为它无法继续:

> ghci -v0 --interactive -ignore-dot-ghci -isrc -idist/build/autogen tests/System/Console/Hawk/PreludeTests.hs -no-user-package-db -package-db /mnt/git/hawk/.cabal-sandbox/x86_64-linux-ghc-7.6.3-packages.conf.d
*System.Console.Hawk.PreludeTests> test [] "1" ""


GHCi runtime linker: fatal error: I found a duplicate definition for symbol
   __stginit_stringsearchzm0zi3zi6zi5_DataziByteStringziSearch
whilst processing object file
   /mnt/git/hawk/.cabal-sandbox/lib/x86_64-linux-ghc-7.6.3/stringsearch-0.3.6.5/libHSstringsearch-0.3.6.5.a
This could be caused by:
   * Loading two different object files which export the same symbol
   * Specifying the same object file twice on the GHCi command line
   * An incorrect `package.conf' entry, causing some object to be
     loaded twice.
GHCi cannot safely continue in …

我有一个与Data.List和deleteBy的签名有关的问题.理想情况下,此函数应该输入谓词并删除谓词为true的第一个元素.就像是:

deleteBy :: (a -> Bool) -> [a] -> [a]
deleteBy p = go
    where go []                   = []
          go (x:xs) | p x         = xs
                    | otherwise   = x:go xs

相反,库中定义的函数同时使用谓词和值:

deleteBy                :: (a -> a -> Bool) -> a -> [a] -> [a]
deleteBy _  _ []        = []
deleteBy eq x (y:ys)    = if x `eq` y then ys else y : deleteBy eq x ys

很容易看出它eq总是x作为第一个参数使用并且x被修复deleteBy,所以没有理由得到两个 …

我正在尝试通过实现我自己的懒惰列表版本来学习如何在Scala中使用内置的懒惰:

object LazyList {

  def empty[A] : LazyList[A] = new LazyList[A] {
    lazy val uncons = None
  }

  def cons[A](h : => A, t : => LazyList[A]) : LazyList[A] = new LazyList[A] {
    lazy val uncons = Some( (h,t) )
  }

  def from(s : Int) : LazyList[Int] = new LazyList[Int] {
    lazy val uncons = Some( (s,from(s + 1)) )
  }
}

trait LazyList[A] {

  import LazyList._

  def uncons : Option[(A,LazyList[A])]

  def fmap[B](f : A => B) : LazyList[B] = …

我在Scala中遇到了类型类的问题,更准确地说,在编译时无法找到类型类实例时出现错误.比方说,我有一个类型类TC和对象B[C]具有的实例TC只有当C有一个实例TC.在Scala中,这可以写成implicit def btc[C](implicit ctc: TC[C]) = new TC[B[C]] { ... }.当你需要TC[B[C]]一个C针对scalac无法找到一个实例TC[C],scalac会给一个错误,指出它无法找到TC[B[C]].虽然这是真的,但错误消息缺少scalac无法找到的原因TC[B[C]],即它无法找到TC[C].

为了说明这个问题,我决定制作一个小玩具示例,其中TC是PrettyPrintable,C是Unit和B是Option:

import scala.annotation.implicitNotFound

@implicitNotFound("Cannot pretty print instances of the type ${T}")
trait PrettyPrintable[T] {
  def prettyPrint(t: T): String
}

object PrettyPrintable {
  def apply[T](implicit pp: PrettyPrintable[T]): PrettyPrintable[T] = pp

  implicit def optPP[T](implicit opp: …

如果出现以下情况,Haskell的类型默认规则会默认带有约束的类型变量a (C1 a,...,Cn a):

• 类型变量a不出现在其他约束中
• 所有Ci类都是标准的.
• Ci类中的至少一个是数字

这对我来说很有意义,但它也非常有限:在实践中,这意味着当你使用自定义类时,它总是必须指定类型.例如,这不编译:

class (Show a) => MyShow a where
    myShow :: a -> String
    myShow = show

instance (MyShow a) => MyShow (Maybe a) where
    myShow Nothing = "Nothing"
    myShow (Just x) = "Just " ++ (myShow x)

main = print $ myShow Nothing -- ambiguous

GHCi以这种方式扩展了这套规则:

• 所有类Ci都是单参数类型.
• Ci类中的至少一个是数字,或者是Show,Eq或Ord.

GHC有一个名为ExtendedDefaultRules的扩展,可以启用这些规则.但是这个扩展非常具体:它只适用于GHC和标准类.例如,可以考虑不使用标准库的库.在这种情况下,GHCi扩展将不起作用.

我的问题是:扩展Haskell的类型默认规则(如GHCi)的唯一方法是使用编译器扩展吗？更通用:有没有办法根据Haskell 98中约束的某些规则来定义类型默认？

我有一个与Show相同的类,我想为每个元组类型创建一个这个类的实例.通常,这是通过为每个元组类型单独写入实例来完成的

instance  (Show a, Show b) => Show (a,b)  where
  showsPrec _ (a,b) s = show_tuple [shows a, shows b] s

instance (Show a, Show b, Show c) => Show (a, b, c) where
  showsPrec _ (a,b,c) s = show_tuple [shows a, shows b, shows c] s

instance (Show a, Show b, Show c, Show d) => Show (a, b, c, d) where
  showsPrec _ (a,b,c,d) s = show_tuple [shows a, shows b, shows c, shows d] s …

我正在尝试使用 pureConfig 和 configFactory 进行我的 Spark 应用程序配置。这是我的代码：

import pureconfig.{loadConfigOrThrow}
object Source{
  def apply(keyName: String, configArguments: Config): Source = {
    keyName.toLowerCase match {
      case "mysql" =>
          val properties = loadConfigOrThrow[DBConnectionProperties](configArguments)
          new MysqlSource(None, properties)
      case "files" =>
        val properties = loadConfigOrThrow[FilesSourceProperties](configArguments)
        new Files(properties)
      case _ => throw new NoSuchElementException(s"Unknown Source ${keyName.toLowerCase}")
    }

  }
}

import Source
val config = ConfigFactory.parseString(result.mkString("\n"))
    val source = Source("mysql",config.getConfig("source.mysql"))

当我从 IDE (intelliJ) 或直接从 java (即 java jar...) 运行它时，它工作正常。

但是当我使用 Spark-submit 运行它时，它失败并出现以下错误：

Exception in thread "main" java.lang.NoSuchMethodError: shapeless.Witness$.mkWitness(Ljava/lang/Object;)Lshapeless/Witness; …

在 Linux 中，有两种不同的信号可用于暂停进程：SIGSTOP和SIGTSTP。两者都不由HotSpot 虚拟机处理，SIGSTOP 是因为无法捕获，SIGTSTP 是因为不由HotSpot处理。我想知道发送这两个信号是否安全，或者如果不安全，JVM 的哪些部分会受到影响（例如垃圾收集器）。请注意，我不关心 JVM 上运行的程序可能出现的问题，我对JVM的内部结构特别感兴趣。向JVM发送STOP/TSTP是否安全？