小编Paw*_*mar的帖子

由于状态 monad 可以分解为产品（左 - 函子）和阅读器（右 - 可表示）。

1. 有没有办法分解 Continuation Monad？下面的代码是我的尝试，它不会类型检查

-- To form a -> (a -> k) -> k
{-# LANGUAGE MultiParamTypeClasses, TypeOperators, InstanceSigs, TypeSynonymInstances #-}
type (<-:) o i = i -> o
-- I Dont think we can have Functor & Representable for this type synonym

class Isomorphism a b where
   from :: a -> b
   to :: b -> a

instance Adjunction ((<-:) e) ((<-:) e) where
   unit :: a -> (a -> e) -> e …

我试图理解 Haskell 中的存在类型并遇到了一个 PDF http://www.ii.uni.wroc.pl/~dabi/courses/ZPF15/rlasocha/prezentacja.pdf

请纠正我到目前为止的以下理解。

• Existential Types 似乎对它们包含的类型不感兴趣，但是模式匹配它们说存在某种类型，我们不知道它是什么类型，除非我们使用 Typeable 或 Data。
• 当我们想要隐藏类型（例如：用于异构列表）或者我们在编译时不知道类型是什么时，我们会使用它们。
• GADT's 通过提供隐式forall's为使用存在类型的代码提供清晰和更好的语法

我的疑惑

• 在上面 PDF 的第 20 页中，下面的代码提到函数不可能要求特定的缓冲区。为什么会这样？当我起草一个函数时，我确切地知道我将使用什么样的缓冲区，尽管我可能不知道我将放入哪些数据。什么是错在有:: Worker MemoryBuffer Int如果他们真的想在抽象缓冲区他们能有一个求和型data Buffer = MemoryBuffer | NetBuffer | RandomBuffer和有型状:: Worker Buffer Int

data Worker x = forall b. Buffer b => Worker {buffer :: b, input :: x}
data MemoryBuffer = MemoryBuffer

memoryWorker = Worker MemoryBuffer (1 :: Int)
memoryWorker :: Worker Int

• 由于 Haskell 是一种像 C 一样的全类型擦除语言，那么它如何在运行时知道要调用哪个函数。是不是我们要维护很少的信息并传入一个巨大的函数 V 表，然后在运行时它会从 …

我正在开发一款需要从用户那里获取输入并根据其执行某些操作的产品。我们已经通过打字通过聊天框实现了它，它满足了我们的目的。对于未来的版本，我们希望在聊天窗口中添加语音识别功能。我们想到使用

window.speechRecognition() || window.webkitSpeechRecognition()

但我们发现浏览器中可用的功能使用的是 Google 的 Cloud Speech API。当我们处理非常敏感的用户信息时，这将是安全问题。是否有任何其他替代方案来实现在任何浏览器中工作的语音识别。

我是Haskell的新手。

在研究文件夹时，许多人建议使用它，并避免显式递归，这可能导致内存效率低下的代码。 https://www.reddit.com/r/haskell/comments/1nb80j/proper_use_of_recursion_in_haskell/

当我运行上面链接中提到的示例时。我可以看到显式递归在内存方面做得更好。首先，我认为May可以在GHCi上运行还不是完美的基准，因此我尝试使用进行编译stack ghc。顺便说一句，我如何通过堆栈ghc传递编译器优化标志。我在表达式中缺少什么避免显式递归。

find p = foldr go Nothing
    where go x rest = if p x then Just x else rest

findRec :: (a -> Bool) -> [a] -> Maybe a
findRec _ [] = Nothing
findRec p (x:xs) = if p x then Just x else (findRec p xs)

main :: IO ()
main = print $ find (\x -> x `mod` 2 == 0) [1, 3..1000000] 
main = print $ findRec …

下面是我为 Continuation Monad 尝试的代码示例

newtype Cont r a = Cont { rC :: (a -> r) -> r }

instance Functor (Cont r) where
  fmap :: (a -> b) -> Cont r a -> Cont r b
  fmap f (Cont aCont) = Cont $ \k -> aCont (\a -> k (f a))

instance Applicative (Cont r) where
  pure :: a -> Cont r a
  pure a = Cont $ \k -> k a

  (<*>) :: Cont r (a -> b) …

我明白,借用它不能比它指向的东西的存在更长久,以消除悬空指针.

通过伪造生命期,借用或别名可以超过所有者:

fn main() {
    let e;
    let first = "abcd";
    {
        let second = "defgh";
        e = longest(first, second);
    }
    println!("{}", e);
}

fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
    if first.len() > second.len() {
        first
    } else {
        second
    }
}

结果:

defgh

在上面的例子中,变量e具有比具有更长的寿命second变量并明确了first与second变量寿命是不同的.

当e使用longest(first, second)它初始化时,得到second变量,其函数调用的生命周期是伪造的,因为它等于first但是它被限制在块中并且被分配给e它将比它更长second.为什么这样好？

newtype Cont k a = Cont { runCont :: (a -> k) -> k }

instance Functor (Cont k) where
  -- fmap :: (a -> b) -> (Cont k a) -> (Cont k b)
  fmap f (Cont akTok) = Cont $ ???

我的疑惑：

1. 我们只能将 Functor 实例写入任何可以产生类型输出的数据类型（例如：[a], Maybe a, (y -> a)），但不能用于消耗类型的数据类型。现在，在上述数据键入它消耗了功能消耗一个那么这如何间接消耗的可视为生产型一个。这意味着我们不能为(k -> a) -> k编写 Functor 实例？

2. 如何读取Cont数据类型。续产生ķ时，它有一个？（就像 Javascript XHR 回调在从服务器获取数据时生成 JSON 一样？）

3. 如何为Cont数据类型编写 …

我正在阅读"Haskell编程"一书,并尝试将haskell的想法与我在C#中的知识联系起来.如果我错了,请纠正我.

我觉得monad强制程序员编写可以处理异常的代码.所以我们将明确提到类型系统中的错误处理

Optional(Int) functionName(Int a, Int b)

返回类型是Optional(Int)但不是Int,所以谁曾经使用具有这种返回类型的库将理解错误处理正在发生,结果将像None(解释出错)和Some(解释我们得到了一些结果).

任何代码都可以导致Happy Path(我们得到一些结果)和Sad Path(发生错误).在类型系统中明确地创建这个路径就是monad.这是我对它的理解.请指正.

Monads就像是Pure Functional Programming和Impure代码之间的桥梁(导致副作用).

除此之外,我想确保我对异常处理(VS)选项类型的理解.

异常处理尝试在不深入了解输入的情况下执行操作.异常处理是重的,因为调用堆栈必须放松直到它到达Catch || 救援|| 处理代码.

处理事物的功能方法是在执行操作之前检查输入,如果输入与所需条件不匹配则返回"无".选项类型是处理错误的轻量级.

要求：

urls = [url1, url2, url3]

并行触发所有 3 个 url 并在 urls 列表的序列中绘制 Dom

 ex: Finished order of urls = [url3, url1, url2]
     when url1 finishes Immediately render the DOM, without waiting for url2
     If url2, url3 finishes before url1, then store url2, url3 and paint the DOM after url1 arrives
     Paint the DOM with order [url1, url2, url3]

我的工作使用承诺：

// Fired all 3 urls at the same time
p1 = fetch(url1)
p2 = fetch(url2)
p3 = fetch(url3)

p1.then(updateDom)
  .then(() …

在Haskell中，Applicatives被认为比Functor更强大，这意味着我们可以使用Applicative来定义Functor，例如

-- Functor
fmap :: (a -> b) -> f a -> f b
fmap f fa = pure f <*> fa

和Monads被认为比Applicatives＆Functors更强大。

-- Functor
fmap :: (a -> b) -> f a -> f b
fmap f fa = fa >>= return . f

-- Applicative
pure :: a -> f a
pure = return

(<*>) :: f (a -> b) -> f a -> f b
(<*>) = ???  -- Can we define this in terms return & …

为什么借用检查器会对下面代码中的生命周期感到困惑

fn main() {
    let ss = "abc"; // lets say 'a scope
    let tt = "def"; // lets say 'b scope
    let result = func(ss, tt);
}    

fn func(s: &str, t: &str) -> &str {
    t
}

| fn func(s: &str, t: &str) -> &str {
|                              ^ expected lifetime parameter
|
= help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `s` or `t`

为什么这个代码会发生什么？我错过了一些非常重要的边缘案例吗？

但是当我用生命时间标签对它们进行注释时,它可以工作.

fn …

我是Haskell的新手。

我想使用Enum类为自定义数据类型实现Ord类。

data DayOfWeek
  = Mon | Tue | Weds | Thu | Fri | Sat | Sun
  deriving (Eq, Show)    

instance Enum DayOfWeek => Ord DayOfWeek where
  compare a b = compare (fromEnum a) (fromEnum b)

instance Enum DayOfWeek where
  toEnum 1 = Mon
  toEnum 2 = Tue
  toEnum 3 = …