口粮：
{-# LANGUAGE ForeignFunctionInterface #-}
import GHC.Ptr
import Foreign
import Foreign.C
import Control.Monad
foreign import ccall unsafe "fibonacci.c fib" c_fib :: Int -> Int
example :: IO ()
example =
print (c_fib 5)
main = example
斐波那契
int fib(const int n) {
if (n == 1) {
printf("here");
return 1;
}
else {
return n*fib(n-1);
}
}
结果：
120 // does not print "here"
到底是怎么回事？
这是我目前所拥有的：
instance Monad Ptr where
return = pure
(>>=) (Ptr t) f = f t
抛出的错误是：
• Couldn't match a lifted type with an unlifted type
When matching types
a :: *
GHC.Prim.Addr# :: TYPE 'GHC.Types.AddrRep
• In the first argument of ‘f’, namely ‘t’
In the expression: f t
In an equation for ‘>>=’: (>>=) (Ptr t) f = f t
• Relevant bindings include
f :: a -> Ptr b (bound at RegionalMemory.hs:16:19)
(>>=) :: Ptr a -> (a -> Ptr b) -> Ptr b
(bound at RegionalMemory.hs:16:5)
|
16 | (>>=) (Ptr t) f = f t
| ^
我不太明白这个错误。我做错了什么？
我正在学习延续的概念。我认为一个好主意是追踪用延续形式编写的典型阶乘代码。我想知道我的理解是否正确。
代码：
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
这是我->迄今为止收集到的有关操作员（？）的信息：
现在看一下以下函数类型声明：
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>>比较仅使用计数器并返回具有较大计数器的类（作为两者中较大的一个）。
我将如何实现这一目标？我的猜测是比较器开始发挥作用，正如此处所示。然而，我无法完全确定它。它是否像仅使用比较器中的比较（对象，对象）一样简单，还是其他东西？
到目前为止我收集到的内容：
我认为该模式的含义是：
该行必须以 ana或 a开头b，或者必须以 a 结尾c，或者必须是空字符串。不过，我在绘制图案的 dfa 时遇到了麻烦。让我失望的是“可选”符号。我无法理解该语言不接受哪些字符串。
有人能指出我正确的方向吗？