小编Gro*_*ozz的帖子

我对Scala的新手在尝试阅读David Pollack的Beggining Scala时有点新意.他定义了一个简单的递归函数,它从文件中加载所有字符串:

def allStrings(expr: => String): List[String] = expr match {
    case null => Nil
    case w => w :: allStrings(expr)
}

它优雅而且很棒,只是当我试图加载一个庞大的字典文件时它抛出了一个StackOverflow异常.

现在据我所知,Scala支持尾递归,因此函数调用不可能溢出堆栈,可能编译器无法识别它？所以经过一些谷歌搜索后我尝试了@tailrec注释来帮助编译器,但它说

error: could not optimize @tailrec annotated method: it contains a recursive call not in tail position
def allStrings(expr: => String): List[String] =

我理解尾递归错了吗？我该如何修复此代码？

我是Akka的新手,在参考手册中找不到答案.

假设我们有远程actor分布在3台机器(A,B,C)的集群中,其中一个actor存在于每台机器上,而其他actor则有actorRef到另外两台机器,即:

Machine A:
A (real actor)
-> B (ref)
-> C (ref)

Machine B:
-> A (ref)
B (real actor)
-> C (ref)

Machine C:
-> A (ref)
-> B (ref)
C (real actor)

Actor A执行以下代码:

bRef ! msg1
bRef ! msg2

Actor B在消息处理程序中执行以下代码:

case msg1 => 
    cRef ! msg3
    aRef ! msg4

Actor C在消息处理程序中执行以下代码:

case msg3 => 
    aRef ! msg5

我可以做出以下假设(如果有的话):

1. 演员B在获得msg2之前得到msg1

2. 演员A在获得msg4之前获得msg5

而后续问题可能导致了解上述内容:是否发送了消息!运营商是通过网络真正异步还是等到接收邮箱获得它？即行

bRef ! msg1

阻止,直到演员B在其邮箱中获取消息,或者它是否产生处理传递并继续执行的线程

bRef ! msg2

在它甚至知道演员B得到msg1之前？

在斯坦福斯卡拉课程中,我遇到了以下任务:

练习1 - 设置为函数:

在本练习中,我们将表示集合作为从Ints到Booleans的函数:

type Set = Int => Boolean

a)编写一个函数"set",它接受一个I​​nt参数并返回一个包含该Int的Set.

b)编写一个函数"contains",它将Set和Int作为参数,如果Int在Set中则返回true,否则返回false.

c)编写函数"union","intersect"和"minus",它们将两个Sets作为参数并返回一个Set.

d)你能编写一个函数"subset",它将两个Sets作为参数,如果第一个是第二个的子集,则返回true,否则返回false？

a,b和c的解决方案相当简单:

def set(i: Int): Set = n => n == i

def contains(s: Set, i: Int) = s(i)

def union(a: Set, b: Set): Set = i => a(i) || b(i)

def intersect(a: Set, b: Set): Set = i => a(i) && b(i)

def minus(a: Set, b: Set): Set = i => a(i) && !b(i)

但d …

我正在尝试动态地将模块加载到我的应用程序中,但我想为每个模块指定单独的app.config文件.

假设我有以下主应用程序的app.config设置:

<appSettings>
  <add key="House" value="Stark"/>
  <add key="Motto" value="Winter is coming."/>
</appSettings>

另一个用于我加载的库Assembly.LoadFrom:

<appSettings>
  <add key="House" value="Lannister"/>
  <add key="Motto" value="Hear me roar!"/>
</appSettings>

两个库都有一个实现相同接口的类,具有以下方法:

public string Name
{
    get { return ConfigurationManager.AppSettings["House"]; }
}

确实Name从主类和加载的汇编类输出调用Stark.

有没有办法让主应用程序使用自己的app.config和每个加载的程序集使用他们的？配置文件的名称在输出中是不同的,所以我认为这应该是可能的.

我有以下高阶函数:

public static Func<T, bool> Not<T>(Func<T, bool> otherFunc)
{
    return arg => !otherFunc(arg);
}

并尝试这样称呼它:

var isValidStr = LinqUtils.Not(string.IsNullOrWhiteSpace);

编译器给我"类型参数不能从使用中推断"错误.但以下工作:

var isValidStr = LinqUtils.Not((string s) => string.IsNullOrWhiteSpace(s));

我想知道有什么区别？ string.IsNullOrWhiteSpace已经是一个具有完全相同签名的非重载函数.

如评论中所述,以下内容也有效,但仍无法解释为什么在这种情况下类型推断失败:

var isValidStr = LinqUtils.Not<string>(string.IsNullOrWhiteSpace);

为什么ThrowIfNull实施为:

    static void ThrowIfNull<T>(this T argument, string name) where T : class
    {
        if (argument == null)
        {
            throw new ArgumentNullException(name);
        }
    }

不会更好地重写为:

    static void ThrowIfNull<T>(this T argument, string name) where T : class
    {
        if (object.ReferenceEquals(argument, null))
        {
            throw new ArgumentNullException(name);
        }
    }

优点:它有助于避免混淆Equals过载,并可能使代码更清晰.

对此有何不妥？应该有一些.

假设我有一个系统中的整数列表:

let mutable data: int list = [1; 2; 3; 4; 5]

由相对较少的生产者更新(通过添加元素)并被许多消费者消费.

注意:如果消费者收到稍微过时的数据,则可以.

什么是同步访问此变量的正确方法？

A)安全的方法是将此变量包装到代理中并通过序列化消息访问它,我们甚至不需要mutable修饰符.但是这种方法似乎是次优的,因为它会不必要地使所有读访问同步.

B)AFAIK引用赋值在.NET中是原子的,因此在一个发布者和所有消费者之间进行简单的赋值就足够了:

出版商: data <- newItem :: data

消费者: data |> process

那么发布商之间的简单锁定就足以结束这个工作流程了吗？

let monitor = object()

出版商: lock monitor (fun () -> data <- newItem::data)

我的假设是对的吗？哪种方法更受欢迎,对于F#来说更为惯用？有更好的选择吗？

请考虑以下代码:

private Dictionary<RobotSettings, Trader> createTradersFor(IEnumerable<RobotSettings> settings)
{
    var traderSet = new Dictionary<Tuple<IGateway, IBroker>, Trader>();

    return settings.ToDictionary(s => s, s =>
    {
        var key = Tuple.Create(s.gateway, s.broker);

        Trader trader = traderSet.TryGetValue(key, out trader)
            ? trader
            : traderSet[key] = new Trader(s.gateway, s.broker);
        return trader;
    });
}

我正在谈论闭包中的trader变量的初始化,它在实例化的同一行中使用它自己.

我最近一直在使用这种处理字典的模式,因为我真的不喜欢未初始化的变量:)并且想知道这是否有保证将来编译.

有没有办法通过F#中的案例标识符比较受歧视的联盟？

type MyUnion =
| MyString of string
| MyInt of int

let x = MyString("hello")
let y = MyString("bye")
let z = MyInt(25)

let compareCases a b =
// compareCases x y = true
// compareCases x z = false
// compareCases y z = false

如何compareCases以通用方式实现功能？

即如下所示,但更通用(反射是可以的):

let compareCases a b =
  match a with
  | MyString(_) -> match b with | MyString(_) -> true | _ -> false
  | MyInt(_) -> match b with | …

我有一个带有接口参数的函数：

func f(e error) {
    if e == nil {
        fmt.Println("YEY! NIL") // how to get here?
    } else {
        fmt.Println("NOT NIL :(")
    }
}

我如何通过它传递一个 nil 值reflect以使其通过== nil检查？

方法一：

func main() {
    rf := reflect.ValueOf(f)

    nilArg := reflect.Zero(reflect.TypeOf((error)(nil))) // panic: reflect: Zero(nil)

    rf.Call([]reflect.Value{nilArg})
}

方法二：

type MyError struct{}
func (e MyError) Error() string {
    return ""
}

func main() {
    rf := reflect.ValueOf(f)
    nilArg := reflect.Zero(reflect.TypeOf(&MyError{})) // NOT NIL :(

    rf.Call([]reflect.Value{nilArg})
}

由于https://golang.org/doc/faq#nil_error，第二种方法不起作用 …

我正在尝试创建某种与实现无关的夹具.

说我有以下界面.

public interface ISearchAlgorithm
{
    // methods
}

我确切地知道它应该如何表现,所以我想为每个派生类运行相同的测试集:

public class RootSearchAlgorithmsTests
{
    private readonly ISearchAlgorithm _searchAlgorithm;

    public RootSearchAlgorithmsTests(ISearchAlgorithm algorithm)
    {
        _searchAlgorithm = algorithm;
    }

    [Test]
    public void TestCosFound()
    {
        // arrange
        // act with _searchAlgorithm
        // assert
    }

    [Test]
    public void TestCosNotFound()
    {
        // arrange
        // act with _searchAlgorithm
        // assert
    } 
    // etc

然后我为每个派生类创建以下灯具:

[TestFixture]
public class BinarySearchTests : RootSearchAlgorithmsTests
{
    public BinarySearchTests(): base(new BinarySearchAlgorithm()) {}
}

[TestFixture]
public class NewtonSearchTests : RootSearchAlgorithmsTests
{
    public NewtonSearchTests(): base(new …

John Palmer在评论中指出明显错误后更新.

以下代码导致OutOfMemoryException:

let agent = MailboxProcessor<string>.Start(fun agent ->

    let maxLength = 1000

    let rec loop (state: string list) i = async {
        let! msg = agent.Receive()

        try        
            printfn "received message: %s, iteration: %i, length: %i" msg i state.Length
            let newState = state |> Seq.truncate maxLength |> Seq.toList
            return! loop (msg::newState) (i+1)
        with
        | ex -> 
            printfn "%A" ex
            return! loop state (i+1)
    }

    loop [] 0
)

let greeting = "hello"

while true do
    agent.Post …