小编Ken*_*oom的帖子

这段代码:

if( someCondition )
    return doSomething();

return doSomethingElse();

与此代码:

if( someCondition )
    return doSomething();
else
    return doSomethingElse();

从本质上讲,它们是相同的,但最佳的风格/表现/ ......(如果当然对答案有任何非自以为是的部分)？还要考虑多个"if else's"的情况:

if( someCondition )
    return doSomething();
else if( someOtherCondition )
    return doSomethingDifferently();
//...
else
    return doSomethingElse();

谢谢!

scala> class A(implicit a: Int);
defined class A

scala> class B()(implicit a: Int);
defined class B

scala> new A()(1)
res1: A = A@159d450

scala> new B()(1)
res2: B = B@171f735

scala> new A(1)
<console>:7: error: too many arguments for constructor A: ()(implicit a: Int)A
       new A(1)

为什么Scalac在类声明中提供的隐式参数列表之前插入一个空参数列表？

从scalac来源的评论来看,这似乎是一个特征,而不是一个错误:

//如果它是唯一的参数部分,则将(隐式...)转换为()(隐式...)

我很想知道为什么这样做.我觉得这很令人惊讶.

#include <stdio.h>

typedef struct node
{
      int i;
      struct node *next;
}node;

node getnode(int a)
{
      struct node n;
      n.i=a;
      n.next=NULL;
      return n;
}

main()
{
     int i;
     node newtemp,root,temp;

     scanf("%d",&i);
     root=getnode(i);
     temp=root;

     while(i--)
     {
         newtemp=getnode(i);

         temp.next=&newtemp;
         if(root.next==NULL)
         {
            root=temp;
         }
        temp=*(temp.next);
     }


     temp=root;

     while( temp.next != NULL )
     {
         printf(" %d ",temp.i);
         temp=*(temp.next);
     }
}

我试图在不使用malloc的情况下创建链表.编程只打印根,后面没有节点.我找不到这个bug.如果有任何内存问题,gcc编译器会抛出一个分段错误.(？)请忽略糟糕的编程风格..

在XCode中,如果右键单击类文件或.xib文件,则有两个菜单项:"Touch"和"Untouch".

他们在做什么？

在scala中使用哪种最简单的API来对文档执行以下XPath查询？

//s:Annotation[@type='attitude']/s:Content/s:Parameter[@role='type' and not(text())]

//s:Annotation[s:Content/s:Parameter[@role='id' and not(text())]]/@type

(s被定义为特定命名空间的昵称)

我在Scala的XML库上找到的唯一文档没有关于执行复杂的真实XPath查询的信息.

我曾经为此目的喜欢JDOM(在Java中),但由于JDOM不支持泛型,因此在Scala中使用会很痛苦.(Java的其他XML库在Java中往往更加痛苦,但我承认我不了解真实情况.)

我有这个正则表达式:

regex = %r{\A(?<foo> a\g<foo>a | b\g<foo>b | c)\Z}x

当我针对几个字符串测试它时,它看起来像上下文无关语法一样强大,因为它正确处理递归.

regex.match("aaacaaa")
# => #<MatchData "aaacaaa" foo:"aaacaaa">
regex.match("aacaa")
# => #<MatchData "aacaa" foo:"aacaa">
regex.match("aabcbaa")
# => #<MatchData "aabcbaa" foo:"aabcbaa">
regex.match("aaacaa")
# => nil

" Ruby 1.9正则表达式的乐趣 "有一个例子,他实际上安排了一个正则表达式的所有部分,使它看起来像一个无上下文的语法,如下所示:

sentence = %r{ 
    (?<subject>   cat   | dog   | gerbil    ){0} 
    (?<verb>      eats  | drinks| generates ){0} 
    (?<object>    water | bones | PDFs      ){0} 
    (?<adjective> big   | small | smelly    ){0} 

    (?<opt_adj>   (\g<adjective>\s)?     ){0} 

    The\s\g<opt_adj>\g<subject>\s\g<verb>\s\g<opt_adj>\g<object> 
}x

在他重新排列正则表达式部分的技术和我的递归命名捕获组的例子之间,这是否意味着Ruby 1.9正则表达式具有与无上下文语法相当的能力？

Go语言有一个select语句,可用于轮询多个通道并执行特定操作,具体取决于哪个通道首先是非空的.

例如

select {
  case a := <- chanA:
    foo(a)
  case b := <- chanB:
    baz(b)
  case c := <- chanC:
    bar(c)
}

这将等到chanA,chanB或者chanC非空,然后如果例如chanB非空,它将读取chanB并存储结果b,然后调用baz(b).default:还可以添加一个子句,这意味着select语句不会在通道上等待,而是default在所有通道都为空的情况下执行该子句.

TChan在Haskell中为STM实现这样的事情的最佳方法是什么？它可以通过if-else链天真地完成:检查每个chan isEmptyChan,如果它不是空的,那么从它读取并调用适当的函数,或者retry如果所有通道都是空的则调用.我想知道是否会有更优雅/惯用的方式来做到这一点？

请注意,Go的select语句在其情况下也可以包含send语句,并且只有在其通道为空时才会完成send语句.如果功能也可以重复,那将是很好的,虽然我不确定是否会有一种优雅的方式.

只是略微相关,但我刚注意到的东西,我不知道在哪里发布它:在描述中的Control.Monad.STM页面上有一个拼写错误retry:

"该实现可能会阻止该线程,直到它读取的其中一个TVAR已被更新."

这个班轮......

 Console.println(io.Source.fromFile("names.txt").getLines.mkString.split(",").map{x:String => x.slice(1, x.length -1)}.sortBy { x => x}.zipWithIndex.map{t =>{ (t._2 +1)*(t._1.map{_.toChar - "A"(0).toChar + 1}.sum)}}.sum);

...是我对Project Euler问题22的解决方案.它似乎工作,它写在(我的尝试)功能风格.

这个例子有点极端,但我的问题更为笼统 - 您更喜欢编写/格式化/评论功能样式代码？功能方法似乎鼓励了一系列方法调用,我发现这些方法调用不可读,而且放置注释也无处可寻.

此外,当我编写过程代码时,我发现我编写了一些小方法,每个方法都有一个目的和有意义的名称.当我编写功能代码时,我似乎正在养成一种习惯,这种习惯产生的线条与上面的线条有点差别,其中(对我而言)意义难以破译 - 而且个别计算也难以在其他地方重复使用.我在网上看到的很多功能代码示例同样简洁(对我而言)模糊不清.

我该怎么办？为当前上下文中有意义的名称编写计算的每个部分的小函数？(即使它们只是地图的包装,说？)

对于我给出的例子,有什么更好的方法来编写它并呈现它？

(就像所有风格的问题一样,这个问题是主观的.但是没有理由它应该引起争议!)

在C#中,我可以重载泛型类型的方法,如下例所示:

// http://ideone.com/QVooD
using System;
using System.Collections.Generic;

public class Test {
  public static void Foo(List<int> ints) {
    Console.WriteLine("I just print");
  }

  public static void Foo(List<double> doubles) {
    Console.WriteLine("I iterate over list and print it.");
    foreach(var x in doubles)
      Console.WriteLine(x);
  }

  public static void Main(string[] args) {
    Foo(new List<int> {1, 2});
    Foo(new List<double> {3.4, 1.2});
  }
}

但是,如果我尝试在Scala中执行相同操作,则会引发编译时错误,List[Int]并List[Double]由于擦除而擦除到相同类型.我听说Scala Manifest可以用来解决这个问题,但我不知道怎么做.我也没有在文档中找到任何有用的东西.

所以我的问题是:我如何使用Manifests(或其他任何有效的方法)重载方法而不是因擦除而擦除到相同类型的泛型类型？

在Ruby中,我可以通过以下方式替换字符串中的字符:

a = "one1two2three"
a.gsub(/\d+/) {|e| e.to_i + 1}
=> "one2two3three"

从第二行评估块的结果将替换模式中匹配的块.我们可以在Scala中做同等的事情吗？用函数/匿名函数的结果替换正则表达式中的内容？