I spent the last 18 months getting the grip of functional programming, starting with learning OCaml and for some weeks now Haskell. Now I want to take the next step and implement some actual application: A simple realtime terrain editor. I've written numerous realtime terrain rendering engines, so this is a familiar topic. And the used recursive algorithms and data structures seem very fit
我花了18个月的时间来掌握函数式编程，从学习OCaml开始，几个星期后现在Haskell。 现在我想进行下一步并实施一些实际的应用程序：一个简单的实时地形编辑器。 我编写了许多实时地形渲染引擎，所以这是一个熟悉的主题。 所使用的递归算法和数据结构看起来非常适合功能实现。 有了这个实时应用程序，我自然而然地在寻找我可以获得的最佳性能。 现在一些（恕我直言，非常恼人的）OCaml的支持者相对于OCaml或F＃而言，对Haskel
I'm trying to understand indexed monads in the index-core style. I have become stuck in a paradox which is that I can't understand the principles until I have constructed a few examples, and I can't construct examples until I understand the principles. I am trying to construct an indexed state monad. So far my intuition tells me it should be something like this type a :* b = fora
我试图理解索引index-core风格的索引monad。 我陷入了一个悖论，那就是在构建了一些例子之前，我无法理解这些原则，直到我理解了这些原则之后，我才能构建出例子。 我正在尝试构建一个索引状态monad。 到目前为止，我的直觉告诉我应该是这样的 type a :* b = forall i. (a i, b i) newtype IState f a i = IState { runIState :: f i -> (a :* f) } 并且，我可以恢复通过设置“限制”状态单子f = Identity和选择a适当的：
I have a program I'm trying to parallelize (full paste with runnable code here). I've profiled and found that the majority of time is spent in findNearest which is essentially a simple foldr over a large Data.Map . findNearest :: RGB -> M.Map k RGB -> (k, Word32) findNearest rgb m0 = M.foldrWithKey' minDistance (k0, distance rgb r0) m0 where (k0, r0) = M.findMin m0
我有一个我试图并行化的程序（在这里完全粘贴可运行代码）。 我异型，发现大部分的时间都花在findNearest这基本上是一个简单的foldr在大Data.Map 。 findNearest :: RGB -> M.Map k RGB -> (k, Word32) findNearest rgb m0 = M.foldrWithKey' minDistance (k0, distance rgb r0) m0 where (k0, r0) = M.findMin m0 minDistance k r x@(_, d1) = -- Euclidean distance in RGB-space
Upon a fresh install of the haskell-platform (via homebrew ) ( GHC x64 7.6.3 ) on OSX 10.9.2 I receive the following warnings when I run ghc-pkg check (see below) Warning: haddock-interfaces: /Users/user/.cabal/share/doc/x86_64-osx-ghc-7.6.3/ghc-mod-3.1.7/html/ghc-mod.haddock doesn't exist or isn't a file Warning: haddock-html: /Users/user/.cabal/share/doc/x86_64-osx-ghc-7.6.3/ghc-mod-3.1.7/html
在OSX 10.9.2上全新安装haskell-platform（通过homebrew ）（ GHC x64 7.6.3 ）后，运行ghc-pkg check时会收到以下警告（请参见下文） Warning: haddock-interfaces: /Users/user/.cabal/share/doc/x86_64-osx-ghc-7.6.3/ghc-mod-3.1.7/html/ghc-mod.haddock doesn't exist or isn't a file Warning: haddock-html: /Users/user/.cabal/share/doc/x86_64-osx-ghc-7.6.3/ghc-mod-3.1.7/html doesn't exist or isn't a directory W
I expect type family Rep a and type family Rep :: * -> * to be the same, but it seems there is a difference type family Rep a type instance Rep Int = Char -- ok type family Rep :: * -> * type instance Rep Int = Char -- Expected kind * -> *, but got 'Int' instead Have I simply stumbled over an Haskell extension bug, or is there some point to this behavior? Yes, there is a s
我预计 type family Rep a 和 type family Rep :: * -> * 是一样的，但似乎有区别 type family Rep a type instance Rep Int = Char -- ok type family Rep :: * -> * type instance Rep Int = Char -- Expected kind * -> *, but got 'Int' instead 我只是偶然发现了一个Haskell扩展错误，或者是否有一点指向这种行为？ 是的，有一个微妙的区别。 粗略地说， type family F a :: *->*表明， F Int
I've been experimenting with dependently typed programs using the Data.Singletons library, following the development of length-annotated vectors in the paper, "Dependently Typed Programming with Singletons," and I've run into the following problem. This code, excluding the definition of the function indexI , typechecks in GHC 7.6.3 and works as expected in its absence: {-# LA
我一直在使用Data.Singletons库试验依赖类型的程序，在文章“使用Singletons进行依赖类型化编程”之后开发了长度注释向量，并且我遇到了以下问题。 该代码（不包括函数indexI的定义）在GHC 7.6.3中进行了类型indexI ，并在缺少时按预期工作： {-# LANGUAGE DataKinds #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperat
I have been playing around a bit with closed type families however I somehow always bump my head at the fact that things usually doesn't work for Num without specifying the type. Here is an example. {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE Undecida
我一直在玩一些封闭类型的家庭，但是我总觉得事物往往不适用于Num而没有指定类型。 这是一个例子。 {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE OverlappingInstances #-} {-# LANGUAGE IncoherentInstances #-} {-
I'm confused about how to choose between data family and type family . The wiki page on TypeFamilies goes into a lot of detail. Occasionally it informally refers to Haskell's data family as a "type family" in prose, but of course there is also type family in Haskell. There is a simple example that shows where two versions of code are shown, differing only on whether a data f
我对如何在data family和type family之间进行选择感到困惑。 TypeFamilies上的wiki页面进入了很多细节。 偶尔它会非正式地将Haskell的data family称为散文中的“类型族”，但当然Haskell中也有type family 。 有一个简单的例子，显示了两个版本的代码的显示位置，不同之处仅在于是否声明了data family或type family ： -- BAD: f is too ambiguous, due to non-injectivity -- type family F a -- OK data family F a f ::
I'm trying to write a fairly polymorphic library. I've run into a situation that's easier to show than tell. It looks a bit like this: {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TypeFamilies #-} import Data.Map (Map) import qualified Data.Map as Map class Format f where type Target f class Format f => Formatter x f where target ::
我试图写一个相当多态的库。 我遇到了一个比告诉更容易展现的情况。 它看起来有点像这样： {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TypeFamilies #-} import Data.Map (Map) import qualified Data.Map as Map class Format f where type Target f class Format f => Formatter x f where target :: forall y. Formatable y => Target f -> x -> y class F
With functional dependencies I can constrain type of dependent parameter in a type class using multi-parameter type classes. Just like this: {-# LANGUAGE FunctionalDependencies, MultiParamTypeClasses,TypeSynonymInstances #-} class (Num a, Integral b) => F a b | a -> b where f :: a -> b instance F Int Int where f = id instance F Float Integer where f = truncate And everything
通过函数依赖关系，我可以使用多参数类型类来约束类型类中的依赖参数的类型。 像这样： {-# LANGUAGE FunctionalDependencies, MultiParamTypeClasses,TypeSynonymInstances #-} class (Num a, Integral b) => F a b | a -> b where f :: a -> b instance F Int Int where f = id instance F Float Integer where f = truncate 一切都将完美运作。 > f (1 :: Int) 1 > f (1.9 :: Float) 1 但是，