小编mis*_*tor的帖子

考虑以下Scala片段:

case class Foo(v1: String, v2: Int, v3: Any)

def inspect(p: Product) =
  (0 until p.productArity).foreach(i => println(p.productElement(i)))

inspect(Foo("Moin", 77, null))

inspect()这里的调用是否意味着使用反射(以任何方式)？

我想以某种方式能够访问案例类的字段,而不必明确地引用它们,例如foo.v1,我喜欢不需要反射的解决方案,因为我希望它需要一些开销.

我正在尝试创建一个类型类Default,它提供给定类型的默认值.这是我到目前为止提出的:

trait Default[A] {
  def value: A
}

object Default {
  def withValue[A](a: A) = new Default[A] {
    def value = a
  }

  def default[A : Default]: A = implicitly[Default[A]].value

  implicit val forBoolean = withValue(false)

  implicit def forNumeric[A : Numeric] = 
    withValue(implicitly[Numeric[A]].zero)

  implicit val forChar = withValue(' ')

  implicit val forString = withValue("")

  implicit def forOption[A] = withValue(None : Option[A])

  implicit def forAnyRef[A >: Null] = withValue(null : A)
}

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

case class …

我正在尝试编写一个通用fill方法,以下是我到目前为止所提出的方法:

scala> import collection.generic.{GenericTraversableTemplate => GTT}
import collection.generic.{GenericTraversableTemplate=>GTT}

scala> import collection.generic.{TraversableFactory => TF}
import collection.generic.{TraversableFactory=>TF}

scala> def fill[A, CC[X] <: Traversable[X] with GTT[X, CC]]
     |   (n: Int)(elem: => A)(tf: TF[CC]) = tf.fill(n)(elem)
fill: [A, CC[X] <: Traversable[X] with scala.collection.generic.GenericTraversab
leTemplate[X,CC]](n: Int)(elem: => A)(tf: scala.collection.generic.TraversableFa
ctory[CC])CC[A]

scala> fill(3)('d')(List)
res42: List[Char] = List(d, d, d)

这适用于除数组之外的所有可遍历集合.如何使此代码与数组一起使用？

scala> implicit def transitive[A, B, C](implicit f: A => B, g: B => C): A => C = f andThen g
transitive: [A, B, C](implicit f: A => B, implicit g: B => C)A => C

scala> class Foo; class Bar; class Baz { def lol = println("lol") }
defined class Foo
defined class Bar
defined class Baz

scala> implicit def foo2Bar(f: Foo) = new Bar
foo2Bar: (f: Foo)Bar

scala> implicit def bar2Baz(f: Bar) = new Baz
bar2Baz: (f: Bar)Baz …

假设我有两个函数f :: [a] -> b和g :: [a] -> c.我有以下两个问题:

1. 如果我执行(f &&& g) xs,其中xs :: [a],如果都f和g涉及循环,有可能是编译器这两个循环优化成一个？(请注意,我不是在问一些特定的Haskell编译器是否实现了这一点.我想知道这样的事情是否可行.)

2. 类型类中的traverse函数可以Traverse帮助我进行这样的优化,包括以下几行:

   traverse (someCombinator f g) xs
   

   Run Code Online (Sandbox Code Playgroud)

我过去两个小时一直试图理解这个算法,但似乎无法理解.有人可以用容易理解的方式解释一下吗？

function lis_length(a)
    n := a.length
    q := new Array(n)
    for k from 0 to n:
        max := 0;
        for j from 0 to k, if a[k] > a[j]:
            if q[j] > max, then set max = q[j].
        q[k] := max + 1;
    max := 0
    for i from 0 to n:
        if q[i] > max, then set max = q[i].
    return max;

我想编写一个函数saveStuff,在通过某些测试后将某些东西保存到文件中.如果测试失败,我需要引发错误.这个函数的结果类型应该是什么？我想到的IO (Either String ())和IO (Maybe String),但他们都觉得不对出于某种原因.我从标准库中查找了类似的函数,但它们似乎只是返回IO ().他们在失败时抛出异常.我发现自己并不喜欢这种方法.

我的理解是静态成员属于该类.为什么Java允许我用对象访问它们？

要了解我的意思,请参阅以下示例:

public class Student {
  public static int number = 0;
}

这number是一个属于class的静态字段Student,但我仍然可以访问它,如下所示:

Student s = new Student();
int n = s.number;

这个决定背后的理由是什么？

我想在同一个表中有父子关系。以下是我所拥有的，但它不起作用。“不工作”是指当我调用.children某个Item对象时，它会给我[]. 我的代码中有什么错误以及如何正确执行？谢谢。

parents_children = Table('parents_children', Base.metadata,
                         Column('parent_id', bigint, ForeignKey('items.id', name='a'), primary_key=True),
                         Column('child_id', bigint, ForeignKey('items.id', name='b'), primary_key=True)
                         )

class Item(Base):
    __tablename__ = 'items'
    id = Column(bigint, primary_key=True, autoincrement=True)
    name = Column(types.String(80), default="")
    display_name = Column(types.String(80), default="")
    version = Column(types.String(80), default="")
    discriminator = Column(item_tag_enum, nullable=False)
    children = relationship('Item',
                            secondary=parents_children,
                            primaryjoin=id == parents_children.c.parent_id,
                            secondaryjoin=id == parents_children.c.child_id,
                            backref='parents')
    __mapper_args__ = {'polymorphic_on' : discriminator}

 # Item subclasses omitted because that's irrelevant to the question.

是否可以使用其他JVM语言(如Scala和Clojure)来开发IntelliJ IDEA插件？或者我们是否必须为此目的使用Java？我在网上找不到这方面的指示,因此在这里发布问题.