与标准的if-else语句相比,？:运算符有什么好处和缺点.显而易见的是:
有条件的？:运营商
标准If/Else
根据声明,可读性似乎各不相同.在第一次接触到？:运算符后的一段时间内,我花了一些时间来精确地消化它是如何工作的.您是否会建议尽可能使用它,或者坚持if/else,因为我与许多非程序员一起工作？
我已经搜索了一下,但还没有找到一个很好的答案,关于如何将任何条目过滤到地图中的值为None.说我有这样的地图:
val map = Map[String, Option[Int]]("one" -> Some(1),
"two" -> Some(2),
"three" -> None)
我想最后只用("one", Some(1))和("two", Some(2))对返回一张地图.我知道当你有一个列表时,这是通过展平来完成的,但是我不确定如何在不将它分成键和值,然后尝试重新加入它们的情况下在地图上实现效果.
我需要在python中做一些小数位格式化.优选地,浮点值应始终至少显示起始0和小数点后一位.例:
Input: 0
Output: 0.0
具有更多小数位的值应继续显示它们,直到它变为4.所以:
Input: 65.53
Output: 65.53
Input: 40.355435
Output: 40.3554
我知道我可以使用{0.4f}将其打印到小数点后四位,但它会填充不需要的0.是否有格式化代码告诉它打印出一定数量的小数,但如果没有数据则将它们留空？我相信C#通过以下方式完成此任务:
floatValue.ToString("0.0###")
#符号代表可以留空的地方.
我正在练习在Scala中实现一个功能二进制搜索树,遵循我在Haskell中看到的类似模式.我有一个看起来像这样的结构:
trait TreeNode[A] {
def isLeaf: Boolean
def traverse: Seq[A]
...
}
case class Branch[A](value: A, left: TreeNode[A], right: TreeNode[A]) extends TreeNode[A] {
def isLeaf: Boolean = false
def traverse: Seq[A] = ...
...
}
case class Leaf[A]() extends TreeNode[A] {
def isLeaf: Boolean = true
def traverse: Seq[A] = Seq[A]()
...
}
我喜欢把一个类型约束上A,以便它仅接受扩展对象Ordered.它看起来像我需要定义绑定,该视图([A <% Ordered[A]])上Branch和Leaf,还有TreeNode特质.我不能做到这一点的TreeNode特征,但是,因为鉴于界限是不能接受的.
据我所知,<%-style视图边界是implicit定义的语法糖,因此应该有一种方法来编写以在TreeNode …
我一直在使用Scala中的类型类模式,但是当我使用的类型是通用的时,我无法弄清楚如何实现隐式伴随对象.
例如,假设我已经为类型类定义了一个特征,它提供了将事物放入Boxes的函数.
case class Box[A](value: A)
trait Boxer[A] {
def box(instance: A): Box[A]
def unbox(box: Box[A]): A
}
implicit object IntBoxer extends Boxer[Int] {
def box(instance: Int) = Box(instance)
def unbox(box: Box[Int]) = box.value
}
def box[A : Boxer](value: A) = implicitly[Boxer[A]].box(value)
def unbox[A : Boxer](box: Box[A]) = implicitly[Boxer[A]].unbox(box)
这按预期工作,允许我提供Boxer各种类型的实现.但是,当我想要采取的类型本身就是通用的时候,我不知道如何做到这一点.假设我想能够使用我Boxer的任何一个Seq[A].objectScala中的s不能包含类型参数,所以我不知道该去哪里:
// Will not compile - object cannot have type arguments
implicit object SeqBoxer[A] extends Boxer[Seq[A]] { ... } …我是Scala的新手,通过Haskell进行函数式编程的经验非常有限.
我想尝试编写一个从单个输入列表构建的所有可能对的列表.例:
val nums = List[Int](1, 2, 3, 4, 5) // Create an input list
val pairs = composePairs(nums) // Function I'd like to create
// pairs == List[Int, Int]((1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1) ... etc)
我尝试zip在每个元素上使用整个列表,希望它会在整个列表中复制一个项目.它不起作用(只匹配第一个可能的对).我不确定如何重复一个元素(Haskell使用它cycle并且take我相信),并且我在跟踪Scala上的文档时遇到了麻烦.
这让我觉得可能有一种更简洁,更实用的方式来获得我想要的结果.有没有人有一个好的解决方案？
我正在玩Scala 2.11的新宏功能.我想看看我是否可以进行以下重写:
forRange(0 to 10) { i => println(i) }
// into
val iter = (0 to 10).iterator
while (iter.hasNext) {
val i = iter.next
println(i)
}
我认为我对这个宏非常接近:
def _forRange[A](c: BlackboxContext)(range: c.Expr[Range])(func: c.Expr[Int => A]): c.Expr[Unit] = {
import c.universe._
val tree = func.tree match {
case q"($i: $t) => $body" => q"""
val iter = ${range}.iterator
while (iter.hasNext) {
val $i = iter.next
$body
}
"""
case _ => q""
}
c.Expr(tree)
}
调用时会产生以下输出forRange(0 to 10) { i …
在玩Rust时,我发现你可以通过引用而不是使用来循环Vecs和HashMaps(可能还有其他).iter().
let xs = vec![1, 2, 3, 4, 5];
for x in &xs {
println!("x == {}", x);
}
该.iter()函数似乎具有相同的行为.
let xs = vec![1, 2, 3, 4, 5];
for x in xs.iter() {
println!("x == {}", x);
}
两种循环方法在功能上是相同的,还是两者之间的行为有细微差别？我注意到这.iter()似乎是我发现的例子中普遍偏爱的方法.
我有一种情况,我有一个类,在其泛型类型参数中接受某个对象类型的实例.布局是这样的:
public abstract BaseClass { ... }
public DiamondClass : BaseClass { ... }
public SilverClass : BaseClass { ... }
public Handler<T> where T : BaseClass { ... }
我希望能够创建一个方法来返回输入时定义Handler<DiamondClass>或Handler<BaseClass>不定义类型的实例.我试过这些方面的东西:
public Handler<BaseClass> GetHandler(HandlerType type)
{
switch(type)
{
case HandlerType.Diamond: return new Handler<DiamondClass>();
case HandlerType.Silver: return new Handler<SilverClass>();
default: throw new InvalidOperationException("...");
}
}
但这不起作用,因为显然Handler<DiamondClass>不会隐含地施放Handler<BaseClass>.我可以这样指定:
public Handler<T> GetHandler<T>(HandlerType type) where T : BaseClass
{
switch(type)
{
case HandlerType.Diamond: return (Handler<T>)new Handler<DiamondClass>(); …我试图弄清楚如何编写一个适用于任何函数的函数交换函数Traversable[_],给定一个集合和交换索引.我想出了以下内容:
def swap[A, CC <% Traversable[A]](xs: CC, i: Int, j: Int): Traversable[A] = {
xs.slice(0, i) ++
xs.slice(j, j+1) ++
xs.slice(i+1, j) ++
xs.slice(i, i+1) ++
xs.slice(j+1, xs.size)
}
swap(List(1,2,3,4,5), 0, 4) // => List(5,2,3,4,1)
我想知道如何将它变成Traversable的隐式扩展,让我可以调用它List(1,2,3,4,5).swap(0, 4).我能得到的最接近的是:
import language.implicitConversions
class RichTraversable[A, B <% Traversable[A]](xs: B) {
def swap(i: Int, j: Int): Traversable[A] = {
xs.slice(0, i) ++
xs.slice(j, j+1) ++
xs.slice(i+1, j) ++
xs.slice(i, i+1) ++
xs.slice(j+1, xs.size)
}
}
implicit def richTraversable[A, B <% Traversable[A]](ys: …