小编Dan*_*owy的帖子

去年我花了很多时间进行Ruby开发,在那段时间里我发现了irb,这使得运行一些"代码实验"变得简单而有趣.我最近换了团队,现在正在进行Java开发,我发现我真的很想念我的窗口.Java有这样的东西吗？

"使用Eclipse"不是一个好的答案.我正在使用Eclipse(呻吟),但Eclipse的铃声和口哨不是一回事.

我的印象是在lambda表达式中无法进行赋值.例如,以下(当然不是非常有用)代码

Expression<Action<int, int>> expr = (x, y) => y = x;

产生编译器错误

An expression tree may not contain an assignment operator

然而,根据Microsoft的文档,可以使用编程方式创建赋值表达式Expression.Assign.除非我弄错了,否则以下代码会产生等价Expression:

ParameterExpression xparam = Expression.Parameter(typeof(int), "x");
ParameterExpression yparam = Expression.Parameter(typeof(int), "y");
BinaryExpression body = Expression.Assign(yparam, xparam);
var expr = Expression.Lambda<Action<int, int>>(body, xparam, yparam);
var cexpr = expr.Compile();

在这种情况下,编译器不会抱怨.我觉得我在这里错过了一些重要的区别.

假设我有以下抽象类:

abstract class A (var is_happy : Boolean) {
  def toggle_happiness();
}

现在我想定义一个实现该toggle_happiness()方法的具体类:

class B (is_happy : Boolean) extends A (is_happy) {
  def toggle_happiness() = {
    is_happy = !is_happy
  }
}

Scala的编译器给了我:

error: reassignment to val
   is_happy = !is_happy
            ^

这里发生了什么？我认为在我的类中is_happy引用了var由我的构造函数设置的.我和这个名字有冲突is_happy吗？

谢谢,丹

我是Scala的新手,能够将函数传递给其他函数非常简洁 - 但是我可以将任意函数引用传递给另一个函数吗？所述功能参数的arity将是固定的(也就是说,我也很好奇你是否可以传递任意arity的函数).我不断遇到类型错误.我尝试过使用Any但它似乎没有帮助.

例如,我有以下代码:

class CodeRunner(val user_defined: (Int) => Unit) {
  def run(input: Int) = {
    user_defined(input)
  }
}

def arbitrary_code(input: Int) = { println("Running with input " + input) }

val d1 = new CodeRunner(arbitrary_code)

d1.run(4)

我得到:

Running with input 4

现在,让我们说我想传递以下函数:

def arbitrary_code(input: String) = { println("Running with input " + input) }

如何更改我的CodeRunner课程来处理它们？

我有两个用C#编写的库,我想在F#应用程序中使用它.两个库都使用相同的类型,但是,我无法说服F#的类型检查这个事实.

这是使用Office互操作类型的简单示例.F#似乎对这些类型问题特别敏感.在F#方面施放似乎并没有帮助这种情况.所有三个项目都引用了相同的程序集("Microsoft.Office.Interop.Excel"版本14.0.0.0).

在项目"Project1"(C#项目)中:

namespace Project1
{
    public class Class1
    {
        public static Microsoft.Office.Interop.Excel.Application GetApp()
        {
            return new Microsoft.Office.Interop.Excel.Application();
        }
    }
}

在项目"Project2"(C#项目)中:

namespace Project2
{
    public class Class2
    {
        Microsoft.Office.Interop.Excel.Application _app;

        public Class2(Microsoft.Office.Interop.Excel.Application app)
        {
            _app = app;
        }
    }
}

在项目"TestApp"(一个F#项目)中:

[<EntryPoint>]
let main argv = 
    let c2 = Project2.Class2(Project1.Class1.GetApp())
    0 

任何提示？

编辑:

Class2使用以下动态转换更改对构造函数的调用可以解决问题:

let c2 = Project2.Class2(Project1.Class1.GetApp() :?> Microsoft.Office.Interop.Excel.Application)

然而,这是不满意的,因为它是1)动态的,2)我仍然不明白为什么原始类型检查失败.

我最近一直在玩Scala/Java互操作,特别是从Java(7)调用Scala(2.10.4)代码.它比我想象的更令人愉快,但有些事情让我困惑.

例如,scala.runtime我有一个很好的AbstractFunction抽象类集合.但我没有看到任何没有返回值的方法.例如,假设我有以下Scala代码:

class MyClass(name: String) {
  def SayWhat(say_fn: String => Unit) = say_fn(name)
}

我的理解是Java void或多或少是Scala的Unit,所以我可以通过以下Java匿名类来模糊地传递类似lambda的东西:

import scala.Function1;
import scala.runtime.AbstractFunction1;
import scala.runtime.BoxedUnit;

public class MyProgram {
  public static void main(String[] args) {
    MyClass mc = new MyClass("Dan");

    Function1<String, BoxedUnit> f = new AbstractFunction1<String, BoxedUnit>() {
      public BoxedUnit apply(String s) {
        System.out.println("Why, hello there " + s);
          return null;
      }
    };

    mc.SayWhat(f);
  }
}

这显然不是最漂亮的事情,但我AbstractFunction真的很欣赏这些东西,相比之下我不得不做的事情!但是真的没有AbstractProcedure什么东西吗？另外,为什么我的"lambda"必须返回BoxedUnit …

我已经实现了简单的IQueryable和IQueryProvider在LINQ表达式树上收集统计数据的类.这部分工作正常.接下来,我想将表达式树传递给默认的LINQ-to-Objects提供程序进行评估,因为我不需要以任何不同的方式执行它.换句话说,我希望我的提供者收集统计信息作为副作用,将查询传递给默认的LINQ实现.

但是,我很难获得默认提供程序的句柄.我以为我可以简单地保存对原始IEnumerable集合的引用,然后返回默认提供程序(来自我的自定义IQueryable),如:

IQueryProvider IQueryable.Provider
{
    get { return _my_provider.OriginalIEnum().AsQueryable().Provider; }
}

但这不能正常工作.代码最终会抛出一个StackOverflowException.我认为正在发生的事情(从调试模式中的单步执行中收集)是LINQ运行时从上面的方法中获取提供程序,然后从我的自定义中获取表达式树IQueryable,然后它注意到顶级表达式是我的习惯IQueryable.所以它重新开始这个过程,试图找到合适的提供者.它会无休止地执行此操作,直到发生堆栈溢出.

现在,我唯一能想到的就是想出另一个访问者,它生成了另一个IQueryable删除了自定义节点的表达式树,以便LINQ运行时调用默认的提供者.这是相当多的工作,因为我需要访问每个叶子以确保没有嵌套Call表达式IQueryable再次调用我的自定义.有更简单的方法吗？

谢谢您的帮助.

我最近使用Make时遇到了一些奇怪的行为(v3.81).

假设我有以下Makefile:

FOOBAR = $(shell find nonexistentdirectory -iname "foobar" | tr '\n' ' ')

all:
    @echo "Hi"

clean:
    @echo "Hi again"

看起来很简单吧？值得注意的是,它FOOBAR是一个"递归扩展变量",因此在我引用它之前不应该对它进行评估.请注意,我从不提及它.另请注意,nonexistentdirectory不存在您所期望的.

现在假设我FOOBAR 在调用Make目标之前设置了shell:

compy386$ FOOBAR="stuff" make clean
find: nonexistentdirectory: No such file or directory
Hi again

为什么FOOBAR要评估？显然,它与变量在shell中定义的事实有关.我是否应该预料到用户可能在shell中设置了变量？我在这做错了什么？!

我怀疑这个功能不存在的原因是实现它很复杂,很少有人需要它.为了安全起见,您需要固定工作,即,您希望固定可到达对象的整个图形.但它似乎并不是从根本上无法完成的事情.

例如,假设您有以下类:

[StructLayout(LayoutKind.Sequential)]
class SomeObject
{
    public SomeObject r;
}

您分配的内容如下:

SomeObject o = new SomeObject();

并尝试将其固定:

GCHandle oh = GCHandle.Alloc(o, GCHandleType.Pinned);

你会得到可怕的:

Object contains non-primitive or non-blittable data.

好的,好的,我可以忍受.但是假设我可以访问.NET的垃圾收集器实现.会有什么障碍？以下是我看到的障碍:

1. 循环参考.
2. 您希望垃圾收集器将自己限制为应用程序堆内的对象.
3. 这可能需要很长时间.
4. 使操作成为原子是困难/痛苦的.

在我看来,GC已经必须处理其中的一些问题.那我忘记了什么？

注意:在你问"你想要完成什么？"等之前,我要求的目的是研究代码,不一定限于C#,也不一定限于CLR.我知道摆弄运行时自己的内存并不是一个典型的场景.无论如何,这不是一个纯粹的推测性问题.

注2:另外,我不关心编组.我只关心钉扎.

这是一个非常简单(完整)的程序,用于练习使用GCHandle.FromIntPointer:

using System;
using System.Runtime.InteropServices;

namespace GCHandleBugTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = new int[10];

            GCHandle handle = GCHandle.Alloc(arr, GCHandleType.Pinned);
            IntPtr pointer = handle.AddrOfPinnedObject();
            GCHandle handle2 = GCHandle.FromIntPtr(pointer);
        }
    }
}

请注意,此程序本质上是通过C#(4e)(第547页)在CLR上用英语描述的过程的音译.然而,运行它会导致非托管异常,例如:

Additional Information: The runtime has encountered a fatal error. The address of the error was at 0x210bc39b, on thread 0x21bc. The error code is 0xc0000005. This error may be a bug in the CLR or in …

您可以在Scala中执行以下操作非常简洁:

scala> class FooBar
defined class FooBar

scala> val a = new FooBar
a: FooBar = FooBar@7efeedca

scala> val the_class = a.getClass
the_class: java.lang.Class[_ <: FooBar] = class FooBar

scala> val b = the_class.newInstance
b: FooBar = FooBar@1ef1df56

假设我想the_class直接设置值.我似乎能够声明一个正确类型的变量:

scala> var the_class: java.lang.Class[_ <: FooBar] = null
the_class: java.lang.Class[_ <: FooBar] = null

但我似乎无法将变量绑定到任何值.这可能吗？

scala> the_class = class FooBar
<console>:1: error: illegal start of simple expression
       the_class = class FooBar
                   ^
scala> the_class = FooBar
<console>:9: error: not …

这可能是一个半生不熟的想法,但我可以复制表达式的环境吗？请考虑以下示例:

class foo[T](block: => T) {
  var data = { () => block }
  def run() = { data() }
}

var a = 5

var b = new foo({ a += 1; println(a) })
var c = new foo({ a += 1; println(a) })

b.run()
c.run()
b.run()
c.run()

我得到以下输出:

6
7
8
9

但我真正想要的是以下内容:

6
6
7
7

简而言之,foo一旦初始值得到解决,我希望在块中有变量的副本而不是引用它们.可以这样做吗？ scala.util.DynamicVariable似乎很有希望,但我很难理解如何在上面的例子中使用它.

假设我有一个接口Thing:

abstract class Thing[A](a_thing: A) {
  def thingA = a_thing
}

我实现Thing如下:

class SpecificThing(a: String) extends Thing[String](a)

此外,假设我有一个函数,它接受一个Thing和一个lambda做的事情Thing作为参数:

def doSomething[A](fn: Thing[A] => A, t: Thing[A]) : A = fn(t)

现在,让我们使用这些东西:

val st = new SpecificThing("hi")
val fn1: (Thing[String]) => String = (t: Thing[String]) => { t.thingA }
println(doSomething(fn1, st))

这打印hi.到现在为止还挺好.但我很懒,而且我不喜欢打字这么多,所以我将程序改为以下内容:

type MyThing = Thing[String]
val st = new SpecificThing("hi")
val fn2: (MyThing) => String = (t: MyThing) => { t.thingA …