标签: seq

Clojure的:

1:13 user=> (first (conj '(1 2 3) 4))
4
1:14 user=> (first (conj [1 2 3] 4))
1
; . . .
1:17 user=> (first (conj (seq [1 2 3]) 4))
4

我理解发生了什么,但这应该有所不同吗？

正如这个答案所示,当涉及到等式推理时,seq结合undefined非常奇怪的事情,例如它可以使任何monad失败.另一个例子就是这个问题.

最近我偶然发现evaluate :: a -> IO a了类似的事情 - 它评估了它对WHNF的论证,但仅在IO评估行动时.这似乎更安全,因为人们期望"在IO我们能做的一切".当然它不能在任何地方使用,但通常需要评估表达式以某种方式与IO操作连接(比如强制生成线程在使用MVars 时评估计算而不是消耗线程).

所以我想问一下,安全性如何evaluate？是否有可能创建示例(IO当然涉及)它会破坏代码的推理seq？或者我可以将其视为安全替代seq(如果特定程序可能)？

I want to produce such file (cartesian product of [1-3]X[1-5]):

1 1
1 2
1 3
1 4
1 5
2 1
2 2
2 3
2 4
2 5
3 1
3 2
3 3
3 4
3 5

I can do this using nested loop like:

for i in $(seq 3) 
do
  for j in $(seq 5)
  do
      echo $i $j
  done
done

is there any solution without loops?

在Scala Collection文档中,这个问题有一些线索:

Trait Seq有两个子线段LinearSeq和IndexedSeq.这些不添加任何新操作,但每个都提供不同的性能特征:线性序列具有有效的头部和尾部操作,而索引序列具有有效的应用,长度和(如果可变的)更新操作.

但这不能解决我何时使用IndexedSeq而不是Seq？我需要一些真实的例子,IndexedSeq或者LinearSeq这些集合比这些更好Seq.

我目前正在研究一个用C#编写的GUI的F#库,我想问一下将F#(通用)列表传递给C#代码(通用IEnumerable)的最佳或正确方法是什么.

到目前为止我找到了三种方法:

[1; 2; 3; 4; 5;] |> List.toSeq

[1; 2; 3; 4; 5;] |> Seq.ofList 

[1; 2; 3; 4; 5;] :> seq<int>

请问这三种方法有什么实际区别吗？

我想在向量中生成缺失值,以便将缺失值按顺序分组,以模拟不同长度的缺失数据的时段.

假设我有一个10 000个值的向量,我想在向量中的随机位置生成12个NA序列,每个序列的随机长度L在1到144之间(144个模拟在时间步长10分钟时缺失值为2天).序列不得重叠.

我怎样才能做到这一点？谢谢.

我试过结合lapply而seq没有成功.

具有3个不同序列的预期输出示例:

# 1 2 3 5 2 NA NA 5 4 6 8 9 10 11 NA NA NA NA NA NA 5 2 NA NA NA...

编辑

我正在处理季节性时间序列,因此NA必须覆盖值而不是作为新元素插入.

我写了一个接受Seq [String]所有子类的对象的方法.不幸的是,它不会接受Array [String]类型的对象.Array [String]不是Seq [String]的子类吗？

scala> def test[T <: Seq[String]](x: T) = {}
test: [T <: Seq[String]](x: T)Unit

scala> val data = "This is a test string"
data: java.lang.String = This is a test string

scala> test(data.split(" "))
<console>:10: error: inferred type arguments [Array[java.lang.String]] do not conform to method test's type parameter bounds [T <: Seq[String]]
              test(data.split(" "))

我注意到seq我的一台计算机上出现了一个奇怪的行为(Ubuntu LTS 14.04):它不使用点作为小数分隔符,而是使用逗号:

seq 0. 0.1 0.2
0,0
0,1
0,2

我的另一台PC上相同版本的seq(8.21)给出了正常点(也是相同的Ubuntu版本).最奇怪的是,当我从第一台机器进入ssh时,我在远程机器上观察到同样的不良行为.即使是从冲突机器提交到远程机器上的作业调度程序(slurm)的bash脚本也存在这个问题.我很迷茫.为什么(以及如何!)发生这种情况？

新的F#开发人员,长期以来的C#开发人员.作为学习F#的练习,我正在通过Eric Lippert关于图形着色的系列工作,从C#转换为F#.我目前正在做第二部分.

最初的C#在博文中 - 这是迄今为止的F#翻译 - 但是它没有编译:

type BitSet = struct
        val bits : int
        private new(b) = { bits = b }

        static member Empty = BitSet(0)

        member this.Contains (item:int) = (this.bits &&& (1<<< item)) <> 0
        member this.Add (item:int) = BitSet(this.bits ||| (1 <<< item))
        member this.Remove (item:int) = BitSet(this.bits &&& ~~~(1<<<item))
        member this.Bits = seq {
                for item in 0..31 do
                    if this.Contains(item) then
                        yield item
            }
    end

这会产生非常神秘的错误"错误FS0406:byref-typed变量'this'以无效方式使用.Byrefs不能被闭包捕获或传递给内部函数"来自Bits:seq <int>的定义.

奇怪的是,将关键字"struct"更改为"class"会产生有效的代码.从C#的角度来看,这似乎是胡说八道,但我确信它背后有一个合理的原因.现在的问题是-如何应我写的位功能？为理解这一点,我需要理解的基本F#原则是什么？

在seqR中的功能会给我一个序列来自x于y一个恒定的一步m:

seq(x, y, m)

例如seq(1,9,2) = c(1,3,5,7,9).

什么是最优雅的方式从中获取的顺序x,以y与交替的步骤m1和m2,这样类似"seq(x, y, c(m1, m2))"会给我c(x, x + m1, (x + m1) + m2, (x + m1 + m2) + m1, ..., y),每次加的步骤之一(不一定达到最高y,当然,如seq)？

例子:x = 1; y = 19; m1 = 2; m2 = 4我明白了c(1,3,7,9,13,15,19).