小编The*_*nce的帖子

我试过这个:

class Functor f where
    fmap :: (a -> b) -> f a -> f b
class (Functor f) => Applicative f where
    pure  :: a -> f a
    (<*>) :: f (a -> b) -> f a -> f b
    fmap f x = pure f <*> x

我懂了:

`fmap' is not a (visible) method of class `Applicative'

如何定义fmapfor Applicative和其他子类Functor？

>>> list=[None]
>>> def list[0](x,y):
  File "<stdin>", line 1
    def list[0](x,y):
             ^
SyntaxError: invalid syntax

如何将函数定义为列表的元素？

在Haskell中,有:

(>>=) :: Monad m => m a -> (a -> m b) -> m b

有功能:(？)

bind2 :: Monad m => m a -> m b -> (a -> b -> m c) -> m c

ghci> show (Left 3)
"Left 3"
ghci> show (Just 0)
"Just 0"
ghci> show (Just (Left 3))
"Just (Left 3)"

Haskell如何自动将括号放在嵌套的构造函数参数周围？

在Haskell中,您可以使用unsafeCoerce覆盖类型系统.如何在F#中做同样的事情？

例如,实现Y-combinator.

这不会输入检查：

module DoesntTypeCheck where {
import Prelude(Either(..));
defaultEither :: a -> Either b c -> Either a c;
defaultEither a (Left _) = Left a;
defaultEither _ b = b;
}

但这确实是：

module DoesTypeCheck where {
import Prelude(Either(..));
defaultEither :: a -> Either b c -> Either a c;
defaultEither a (Left _) = Left a;
defaultEither _ (Right b) = Right b;
}

编译器可能是越野车，一个Either a c类型只能是Left (x::a)或者Right (y::c)，如果它不Left那么它是Right的，我们知道Right …

与商业数学应用程序不同,Sage Math使用Python作为其脚本语言.我不喜欢它,因为它没有尾递归,不是homoiconic,并使用缩进来输出语句块.我怎样才能使用像Scheme这样的其他语言？

在Haskell中,map有类型:

map :: (a -> b) -> [a] -> [b]

请注意,a并且b不是绝对类型而是类型变量,这意味着它们可以是任何类型,只要每个变量在特定函数调用中始终引用相同类型即可.如何在Go中做同样的事情？

这不起作用:

let rec fix f = f (fix f)

解决方案是添加一个额外的参数:

let rec fix f x = f (fix f) x

有没有办法做到这一点使用lazy和Lazy.force呢？

为什么类型Main.main必须是IO ()不IO String或IO Int或IO whatever？

main :: IO ([] Char) -- Type error
main = (>>) ((>>=) getLine putStrLn) getLine