小编lef*_*out的帖子

我了解到type同义词是现有类型的新名称.它可以像

type MyChar = Char

但这种用法是什么意思呢？

class HasField a where
    type FieldType a :: *

Cabal-newstyle 习惯于偶尔无缘无故地从头开始安装所有依赖项。对于使用其他常见软件包的项目lens，这可能需要长达 \xc2\xbd 小时，这很烦人，尤其是当目的只是快速编译对一个月前构建良好的可执行文件的小更改时。

Cabal 确实提供了指定作为约束的选项，例如lens应该使用已经全局安装的版本。然而，每当我尝试时，我就会得到

$ cabal new-run --constraint \'lens installed\'\nResolving dependencies...\ncabal: Could not resolve dependencies:\n[__0] trying: my-example-project-0.1.0.0 (user goal)\n[__1] next goal: lens (dependency of dat103-Justus-lectures)\n[__1] rejecting: lens-5.2, lens-5.1.1, lens-5.1, lens-5.0.1, lens-5,\nlens-4.19.2, lens-4.19.1, lens-4.19, lens-4.18.1, lens-4.18, lens-4.17.1,\nlens-4.17, lens-4.16.1, lens-4.16, lens-4.15.4, lens-4.15.3, lens-4.15.2,\nlens-4.15.1, lens-4.15, lens-4.14, lens-4.13.2.1, lens-4.13.2, lens-4.13.1,\n...\nlens-0.4, lens-0.3, lens-0.2, lens-0.1 (constraint from command line flag\nrequires installed instance)\n[__1] fail (backjumping, conflict set: my-example-project, lens)\nAfter searching the rest of the dependency tree …

Foldable是一个超类Traversable,类似于Functor超类的Applicative和Monad.

类似的情况下Monad,它可以基本上实现fmap为

liftM :: Monad m => (a->b) -> m a -> m b
liftM f q = return . f =<< q

我们也可以效仿foldMap的

foldLiftT :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
foldLiftT f = fst . traverse (f >>> \x -> (x,x))
           -- or: . sequenceA . fmap (f >>> \x -> (x, x))

使用Monoid m …

其他REPL,例如Octave,具有用于浏览命令历史的专用命令.我发现它非常方便(尽管每当我使用这样的功能时我会问自己,为什么我不首先在文件中正确定义该命令？).

GHCi似乎没有这样的功能,我认为它可能不应该 - 这样的交互性会使像Emacs的控制这样的事情比现在更麻烦.

然而,简单地获取整个历史记录然后使用普通的Haskell来浏览它听起来是一项相当简单的任务.有没有在任何地方实现过的？

我来自纯粹的Windows Visual Studio编程背景,几乎没有Linux经验.似乎可以使用VS Code在Julia中编程,但我无法弄清楚如何正确设置.

有没有人有好的例子launch.json,tasks.json或其他可以作为构建示例的文件？

在详细的教程中看到这将是一件好事.

以下typechecks:

instance (Applicative f, Alternative f, Foldable f) => Monad f where 
  (>>=) = flip $ \f -> foldr (<|>) empty . fmap f
  -- Or equivalently
  a >>= b = getAlt . foldMap Alt . fmap b $ a

这实际上是一个有效的Monad实例吗？如果是,为什么不使用它？如果不是,它是否违反任何法律等？我没有证明法律适用,但我也找不到反例.

我有一个函数返回产品的价格,它目前看起来像

priceOfProduct:: Int -> Int -> Int

是否值得宣布

type Price = Int

这样功能就变成了

priceOfProduct :: Int -> Int -> Price ?

我想这样做,然后继续使用Ints元组,如果它们是他们自己的数据结构,它们可能看起来更好.

priceVsTaxed -> Price -> Int -> (Price, Price)

这有用吗？这有必要吗？

这是一个很好的Haskell风格吗？

声明一个看起来更像是重命名现有数据结构好的样式的数据结构？

这个模块

module Foo (Foo, qux) where

data Foo = Foo {bla::Int}

qux :: Foo
qux = Foo 37

使用编译时会引起警告-Wall：

/tmp/wtmpf-file12937.hs:3:17: warning: [-Wunused-top-binds]
    Defined but not used: ‘bla’
  |
3 | data Foo = Foo {bla::Int}
  |                 ^^^

好的–如果bla只是一个独立的函数，这将很容易，应该通过移除来解决bla。但是，为了记录起见，这些字段不仅提供了可以使用的名称，还用作代码中的文档。

摆脱警告的首选方式是什么？

它应该是一个永久性的解决方案，最好保持记录不变，并且最好不要对模块的其余部分禁用任何警告。

我了解如何在 Haskell 中定义同构流和异构流。

-- Type-invariant streams.
data InvStream a where
   (:::) :: a -> InvStream a -> InvStream a

-- Heterogeneous Streams.
data HStream :: InvStream * -> * where
   HCons :: x -> HStream xs -> HStream (x '::: xs)

我们如何将恒定流定义为异构流的特殊情况？如果我尝试定义常量类型流的类型族，则会收到“归约堆栈溢出”错误。我想这与类型检查算法不够懒惰并试图计算整个Constant a类型流有关。

type family Constant (a :: *) :: InvStream * where
  Constant a = a '::: Constant a

constantStream :: a -> HStream (Constant a)
constantStream x =  HCons x (constantStream x)

有什么方法可以解决这个问题并定义恒定的异构流吗？我应该尝试其他类似的结构吗？

zoom 允许我们在实际定义了更多变量的上下文中使用仅使用某些状态变量的状态操作.

{-# LANGUAGE TemplateHaskell #-}

import Control.Lens

import Control.Monad.Trans.State
import Control.Monad.IO.Class

data Galaxy = Galaxy {
    _solarSys :: SolarSystem
  , _otherStars :: String
  } deriving (Show)
data SolarSystem = SolarSystem {
    _sun :: Float
  , _planets :: Int
  } deriving (Show)

makeLenses ''SolarSystem
makeLenses ''Galaxy

main = (`runStateT`Galaxy (SolarSystem 2e+30 8) "") $ do
   zoom solarSys $ do
      sun -= 1e+23
      planets += 1
   liftIO . print =<< get

Galaxy {_solarSys = SolarSystem {_sun = 1.9999999e30, _planets = 9}, …