kesarling He-Him's questions

我正在学习延续的概念。我认为一个好主意是追踪用延续形式编写的典型阶乘代码。我想知道我的理解是否正确。

代码：

fact :: Integer -> (Integer -> Integer) -> Integer
fact 0 k = k 1
fact n k = fact $ n-1 (\v -> k (n*v))

-- call: fact 5 id
-- answer: 120

这是我跟踪代码的方式（我认为能够跟踪它是理解延续性如何工作的基础）：

fact 5 id --> 
fact 4 (\v -> id (5*v)) --> 
fact 3 (\v -> (\v -> id (5*v)) (4*v)) --> 
fact 2 (\v -> (\v -> (\v -> id (5*v)) (4*v)) (3*v)) --> 
fact 1 (\v -> (\v -> (\v -> (\v -> id (5*v)) (4*v)) (3*v))) (2*v)) --> 
fact 0 (\v -> (\v -> (\v -> (\v -> (\v -> id (5*v)) (4*v)) (3*v))) (2*v)) (1*v)) --> 
(\v -> (\v -> (\v -> (\v -> (\v -> id (5*v)) (4*v)) (3*v))) (2*v)) (1*v)) 1

这是应该如何追踪吗，还是我的基本概念错了？

附言：我理解vs 有点令人困惑，但我假设内部v遮蔽了外部v？

口粮：

class Foo s where
    myCons :: Char -> s -> s
    myCons c xs = <my definition of however I wish to interpret this>

instance (Eq, Show) Foo where
    (:) x y = x `myCons` y

错误：

Pattern bindings (except simple variables) not allowed in instance declaration:
      (:) x y = x `myCons` y

我做错什么了？

我想要做的事情：

fooFromList :: [Int] -> Foo
fooFromList [] = Foo []
fooFromList (x:xs) = let x' = (convertDigitToChar x) in x':(fooFromList xs)

仅供参考：进入 Haskell 的第二天

MRE（该函数的作用不重要）：

foo :: Int -> Int -> Int
foo x y
        | x == y = x + y
        | x < y = x
        | x > y = y

这是我->迄今为止收集到的有关操作员（？）的信息：

1. 右结合
2. 它用于函数类型声明中，表示函数参数的类型及其返回类型

现在看一下以下函数类型声明：
foo :: Int -> Int
这声明（什么是合适的词？）一个名为的函数foo，它接受一个Int并返回一个Int。

但是，声明：foo :: Int -> Int -> Intdeclares(?)foo接受 2Int并返回一个，Int这与说foo :: Int -> (Int -> Int)哪个函数接受一个Int并返回一个函数相同，该函数接受一个Int并返回一个Int。

这怎么讲得通呢？难道不应该是这样的吗Int,Int -> Int？

PS：我正在使用的书：Richard Bird 的《使用 Haskell 进行函数式思考》。

我目前正在学习 Haskell，我遇到了以下难题。下面的结构有什么问题？：

zip [1,2,3] [4,5,6]
Result: [(1,4),(2,5),(3,6)]

zipWith (+) [1,2,3] [4,5,6]
Result: [5,7,9]

zipWith (zip) [1,2,3] [4,5,6]
          OR
zipWith zip [1,2,3] [4,5,6]

Result: <interactive>:22:1: error:
    • No instance for (Num [()]) arising from a use of ‘it’
    • In the first argument of ‘print’, namely ‘it’
      In a stmt of an interactive GHCi command: print it

Expected Result: [(1,4),(2,5),(3,6)]

我缺少什么？

Python代码：

i: int = 1
table: list = [[i, bit, None, None] for bit in h]

预期行为：i每次迭代需要增加 1。

伪代码：

i: int = 1
table: list = [[i++, bit, None, None] for bit in h]

考虑下面的代码：

public... main( String[] args ) // yeah yeah, I'm too lazy to type it out
    new ThreadExample().start(); // the run function just prints out "this is run"
}

现在，可能会发生这样的情况：在调用启动的那一刻，调度程序切换回主程序，主程序块结束。start方法创建的线程会发生什么？仍然有一个非守护线程正在运行（我们创建的线程），这意味着程序应该继续执行，否则它可能会成为僵尸线程（我仍然不完全理解这意味着什么......）。可能发生什么（或者在没有同步的情况下“可能”发生什么）？

编辑：

这个问题最好改写为：“start() 方法调用到底做了什么？”
更多信息可以在：为什么我们调用 Thread.start() 方法？

MRE 因为好吧，作业……叹息

这是我遇到的问题：
考虑以下课程：

class MyClass<T extends Comparable<T>> implements Comparable<MyClass<T>> {

... override the compareTo
}

MyClass<Integer>这使我可以与另一个MyClass<Integer>甚至MyClass<MyClass<Integer>>另一个进行比较MyClass<MyClass<Integer>>。但是，作业要求我能够进行比较，MyClass<MyClass<Integer>>因为MyClass<MyClass<String>>比较仅使用计数器并返回具有较大计数器的类（作为两者中较大的一个）。
我将如何实现这一目标？我的猜测是比较器开始发挥作用，正如此处所示。然而，我无法完全确定它。它是否像仅使用比较器中的比较（对象，对象）一样简单，还是其他东西？

到目前为止我收集到的内容：

1. ^ -> 匹配第一个符号
2. $ -> 匹配最后一个符号
3. [] -> 可以出现在该位置的字符集
4. | ->“或”运算符
5. ？-> 前面的条件是可选的

我认为该模式的含义是：
该行必须以 ana或 a开头b，或者必须以 a 结尾c，或者必须是空字符串。不过，我在绘制图案的 dfa 时遇到了麻烦。让我失望的是“可选”符号。我无法理解该语言不接受哪些字符串。

有人能指出我正确的方向吗？