有人能解释一下,为什么我在应用foldLeft函数时省略了点符号,就会看到下面这个编译错误吗?(2.9.2版)
scala> val l = List(1, 2, 3)
res19: List[Int] = List(1 ,2 ,3)
scala> l foldLeft(1)(_ * _)
<console>:9: error: Int(1) does not take parameters
l foldLeft(1)(_ * _)
^
但
scala>
如果我用两个参数创建我自己的类型:
class !:[A, B]
那么在REPL中创建它的一个实例并不能以我想要的方式显示它的类型:
scala> new !:[Int, Int]
res18: !:[Int,Int] = $bang$colon@5eb1479
相反,我希望它像这样显示:
scala> new !:[Int, Int]
res18: Int !: Int = $bang$colon@5eb1479
这在scala中是可能的吗?
在使用Scala编程时,我会做越来越多的函数式工作。但是,在使用中缀表示法时,很难区分什么时候需要括号,什么时候不需要。
例如,下面这段代码:
def caesar(k:Int)(c:Char) = c match {
case c if c isLower => ('a'+((c-'a'+k)%26)).toChar
case c if c isUpper => ('A'+((c-'A'+k)%26)).toChar
case _ => c
}
def encrypt(file:Str
在Scala中,为什么我可以在下面的代码中省略T m 0 (而不是T.m(0))中的点和括号?
scala> object T { def m(i:Int) = 0 == i }
defined module T
scala> T m 0
res19: Boolean = true
但是为什么我不能在下面的代码中省略n(0)中的brakets?
scala> def n(i:Int) = 0 == i
n: (Int)Boolean
scala> n 0
<console>:1: error: ';' expected but integ
在Scala中,我可以创建一个caseclass,case class Foo(x:Int),然后将它放在一个列表中,如下所示:
List(Foo(42))
现在,这里没有什么奇怪的。下面的内容对我来说很奇怪。运算符::是列表上的函数,对吗?对于任何在Scala中只有一个参数的函数,我都可以使用中缀符号来调用它。例如,1 + 2是对象Int上的函数(+)。我刚刚定义的类Foo没有::运算符,那么以下内容是如何实现的呢?
Foo(40) :: List(Foo(2))
在Scala2.8 RC1中,我从交互式提示符获得以下输出:
scala> case class Foo(x:Int)
d
有人知道为什么编译器会在方法调用中应用这种优先级吗?
object Wrap {
case class Vertex(label: String) {
def <--(label: String) = SemiEdge(this, label)
}
case class Edge(from: Vertex, to: Vertex, label: String)
case class SemiEdge(from: Vertex, label: String) {
def -->(to: Vertex) = Edge(from, to, label
在scala中,我可以通过以下方式添加到列表末尾:
val list = List[Integer](1,2,3,4)
val addEndList = list:::List[Integer](101) //now this list has 1,2,3,4,101
我现在正试着在java中这样做,
scala.collection.immutable.List<Integer> list = perform.getScalaListofSize(4); //1,2,3,4
scala.collection.immutable.List<Integer> list
我使用Scala已经有一段时间了,它仍然困扰着我。我不知道他们为什么把它搞得这么复杂。当这个case类只有两个成员时,我正在尝试理解匹配的case类
def main(args: Array[String]): Unit = {
case class X(a: String, i: Int)
def doSome(x: X): Unit = {
x match {
case "x" X 1 => print("ahhh") // <---- HERE !
case X(_, _) =&g
在Scala的不可变集合中,当集合的长度发生变化时,会创建一个新对象。假设我创建了一个不可变的数组,然后执行连接:
object Dcoder extends App
{
var array=Array("abc","xyz")
var change =array++Array("change of object")
}
由于我使用的是一个不可变的集合,而且它的长度已经改变了,那么对象的创建是由这种改变引起的吗?
我是Scala编程语言的新手,在学习的讲稿时,我一直在尝试一些在我脑海中积累起来的东西。
我想我不能真正理解cons操作符是如何工作的,下面是我尝试过的一些方法:
我创建了一个伪随机数生成器,然后尝试创建一个包含一个随机值的列表:
scala> val gen = new java.util.Random
gen: java.util.Random = java.util.Random@1b27332
scala> gen nextInt 3 :: Nil
<console>:7: error: type mismatch;
found : List[Int]
快速问一下,这有什么问题吗?
(get) :: [a] -> Int -> a -- <- line 21
(x:xs) get 0 = x
(x:xs) get (n+1) = xs get n
当我试图加载包含该代码的文件时,ghci给出了这个错误。
Prelude> :load ch6.hs
[1 of 1] Compiling Main ( ch6.hs, interpreted )
ch6.hs:21:0: Invalid type signature
Failed, modules loaded: none.
我正在尝试获取一
让f x y = x * y来吧。我们可以通过两种方式应用这个函数:f 5 6,或者,使用中缀表示法,5 `f` 6。运算符规则是否适用于最后一个表达式?此应用程序的优先级是什么?它只是另一种形式的函数应用,所以它也会有最高的优先级吗?
我认为编译器看到了这种特殊形式(由于``和/或名称以字母(?)开头),并且实际上将其视为普通函数应用程序,而不是将其视为运算符。
泛型可以在Scala中缀符号中使用吗?
例如:
// Example from play-json
Json.obj("name" -> "Joe") \ "name" as[String] // Generics in infix notation
// error: type application is not allowed for postfix operators
理想情况下,我希望实现如下API:
Json.obj("name
我遇到了两个不同的Haskell模块之间的名称冲突,它们希望使用相同的中缀运算符(<*>)。Haskell 98的报告说
modid.varsym
是被允许的,但是我不能让它工作。下面是Test.hs的全部内容
module Test
where
import qualified Test2 as T
three = T.<*>
和Test2.hs
module Test2
where
(<*>) = 3
但是尝试编译时会出现一条错误消息:
Test.hs:6:12: parse error on input `T.<*>'
我试过T
关于'::‘case类,我有两个问题。
::可以用作
case head :: tail => ...
它怎麽工作?这意味着,Scala使用什么流将List实例与::case类进行匹配?假设我有一个带有操作符op的类MyClass,我是否可以创建一个名为op的case类,并将其用作:
case foo op bar => ....
我正在尝试理解List在Scala中的实现。特别是,我正在尝试理解如何使用中缀运算符编写匹配表达式,例如:
a match {
case Nil => "An empty list"
case x :: Nil => "A list without a tail"
case x :: xs => "A list with a tail"
}
如何允许匹配表达式为x :: xs而不是List(x, xs)
所以我遇到了op运算符,但我不明白。 我定义了两个函数: fun op pow1 (x,y) = Math.pow (x,y);
fun pow2 (x,y) = Math.pow (x,y); 它们都有相同的签名: val pow1 = fn : real * real -> real
val pow2 = fn : real * real -> real 它们都有相同的函数调用: pow1 (5.0,6.0);
> val it = 15625.0 : real
pow2 (5.0,6.0);
> val it = 15625.0 : real 那么这两个函数之间
我在理解函数应用程序如何在haskell中使用currying时遇到了问题。如果我有以下函数:
($) :: (a -> b) -> a -> b
我知道要部分应用这个函数,我需要提供(a -> b)函数($的第一个参数)。
那么为什么可以先应用一个值(即反向参数)呢?
($ 0) :: Num a => (a -> b) -> b
这里我漏掉了什么?
我正在分析维基百科上的一些图片链接。我在上偶然发现了这个
当我使用不推荐使用的URLEncoder.encode时,我可以正确地编码重音字符,但是当我指定"UTF-8“参数时,它就失败了。维基百科上的文本是utf8 AFAIK。
Diego+Forl%E2%88%9A%C2%B0n+vs+the+Netherlands.jpg是错误的,而Diego+Forl%C3%A1n+vs+the+Netherlands.jpg是正确的。
scala> first
res24: String = Diego Forlán vs the Netherlands.jpg
scala> j
假设我有
type VS[A] = Validation[String, A]
val v: VS[Option[A]]
val f: A => VS[B]
我想得到一个VS[Option[B]]类型的结果,但是如果v是一个Success(None),那么结果也应该是一个Success(None)。下面是一个例子:
scala> val v: VS[Option[String]] = some("4.5").success
v: VS[Option[String]] = Success(Some(4.5))
scala> val f = (s : Stri
我昨晚在做一个项目,我有一些代码如下:
/* fixes warnings in 2.10 */
import scala.language.implicitConversions
/* had some kind of case class with some members */
case class Wrapper[A](x: A)
/* for convenience's sake */
implicit def aToWrapper[A](x: A) = Wrapper(x)
/* had some kind of Seq */
val xs: List[Wrapper