小编gat*_*ado的帖子

我无法弄清楚如何制作简明的if-then-else表示法,请参阅[ http://hackage.haskell.org/trac/haskell-prime/wiki/DoAndIfThenElse ].这有效,

import System.Environment
main = do
    args <- getArgs
    if (args !! 0) == "hello"
        then
            print "hello"
        else
            print "goodbye"

但这不,并且插入所述分号(请参阅链接)只会导致我的解析错误.

import System.Environment
main = do
    args <- getArgs
    if (args !! 0) == "hello" then
        print "hello"
    else
        print "goodbye"

我在Haskell中有一个持续的声明 - 我可以提前对它进行评估吗？我看到一些看起来很像的代码,

myList = [(a, b), (c, d)]
...
map (f . fst) myList

fst当我对它进行分析时,它会在通话中占用一些时间(它有168M的呼叫).二进制表示myList非常小,例如,可以复制到全局内存[如果这是一个C程序].我正在编译-O3 -optc-O3.

非常感谢!

为自定义类型生成Lift实例

lift在sclv的答案中给出调用的任何表达式都必须是Lift的一个实例.有一个名为library的库th-lift,它将为自定义数据类型生成Lift实例.查看该软件包的文档.

我正在寻找一个可以警告特定不完整模式的pragma.它会使编译器失败,并带有以下(假设的)代码:

{-# FAILIF incomplete-patterns #-}
f :: Int -> Int
f 0 = 0

我正在尝试使用Arrows编写"编译器",并且知道模式匹配已完成将有助于隔离错误.谢谢!

我经常养成使用标准导入块的习惯,因此在需要时我手头有常用的功能.例如,

-- license block

{-# LANGUAGE Arrows,
            DeriveDataTypeable,
            EmptyDataDecls,
            FlexibleContexts,
            FlexibleInstances,
            FunctionalDependencies,
            GADTs,
            MultiParamTypeClasses,
            NoMonomorphismRestriction,
            RankNTypes,
            ScopedTypeVariables,
            StandaloneDeriving,
            TypeOperators,
            TypeSynonymInstances,
            UndecidableInstances,
            ViewPatterns #-}

module MyModule where

import Prelude hiding (id, (.))
import Control.Arrow
import Control.Category
import Control.Exception
import Control.Monad
import Control.Monad.ST

import Data.Array.Diff
import qualified Data.Map as Map
import qualified Data.Set as Set
import qualified Data.Heap as Heap
import qualified Data.List as List
import qualified Data.List.Key as Key
import Data.List.HT
import Data.Maybe
import Data.STRef
import qualified Data.Text as T

由于我没有使用任何花哨的IDE,我宁愿不在每个文件中阅读它.有没有办法创建某种"标准"/"实用程序"模块,重新导出这些函数的名称,所以我只需键入, …

我正在尝试找到一种更优雅的方式来编写以下代码.

class C c where
    type E c :: * -> *

class C c => A c where
    g :: E c a -> E c a

class (C c, A c) => D c where
    f :: E c a -> E c a

instance A c => D c where
    f = g

这会产生错误.

Test.hs:58:9:
    Could not deduce (E c0 ~ E c)
    from the context (A c)
      bound by the instance declaration at Test.hs:57:10-19
    NB: `E' …

我有一个经常使用许多语言功能的Haskell项目,我希望每个源文件的语言扩展块都是相同的.这是一个清单,

{-# LANGUAGE Arrows,
             BangPatterns,
             DefaultSignatures,
             DeriveDataTypeable,
             DeriveFunctor,
             EmptyDataDecls,
             FlexibleContexts,
             FlexibleInstances,
             FunctionalDependencies,
             GADTs,
             GeneralizedNewtypeDeriving,
             MultiParamTypeClasses,
             NamedFieldPuns,
             NoImplicitPrelude,
             NoMonomorphismRestriction,
             OverlappingInstances,
             RankNTypes,
             RebindableSyntax,
             ScopedTypeVariables,
             StandaloneDeriving,
             TemplateHaskell,
             TypeFamilies,
             TypeOperators,
             TypeSynonymInstances,
             UndecidableInstances,
             ViewPatterns #-}

也许对某些人来说这是不好的做法,但我认为语言扩展是我经常编写代码的"Haskell +"的一部分.而且,我希望它在模块之间是相同的.例如,NoImplicitPrelude语言显着改变,我希望所有模块都统一.

问题:如何在不将语言块复制粘贴到每个文件中的情况下如何实现此目的？我经常学习新的语言功能,将其添加到模块A,然后开始处理模块B,并意识到我必须从模块中复制语言块,这很烦人A.

仅仅是CPP因为一个没有做到这#include一点的pragma !提前致谢.

我想用这种类型的签名编写一个函数:

getTypeRep :: Typeable a => t a -> TypeRep

其中TypeRep将是类型表示为一个,而不是为TA.也就是说,编译器应该随时调用位置[自动返回正确的类型表示getTypeRep ],这将有具体的类型一个.

要添加一些上下文,我想创建一个"动态类型"数据类型,其扭曲是它将记住顶级类型,但不记住它的参数.例如,我想将MyClass a转换为Dynamic MyClass,上面的函数将用于创建Dynamic MyClass的实例,用于存储类型参数a的表示.

我不清楚Clojure ->和->>Clojure 之间的区别:从API参考来看,后者似乎是顺序应用多个函数的正确方法,即( - >> xhgf)会导致f(g(h) (x))).

这与Lisp类语言如何区分f(x,y)和(f(x))(y)有关,而Haskell则不正确？(使用数学符号;逗号旨在暗示n-ary函数,而不是tupling).

提前致谢!

编辑

我错了,除了像(def inc#(+ 1%))这样的简单函数之外,它们都没有工作.

下面是一个不工作的函数的例子->或者->>,

(defn mkinc­ [amnt­] (fn [x] (+ x amnt)­))
(-> 3 (mkin­c 2))
; ERROR -- Wrong number of args (2) passed to: sandbox58780$fn--58797$mkinc
((mkinc 2) 3)
; 5

我想写一个光滑的代码(通过打结来节省我很多时间来实现).它大致是这样的,

n <- myinstr n x

在理论上,myinstr应该运行x以获得一个价值,这将成为n.myinstr在Statemonad 中运行,将n进入状态,但这不会影响x计算.

我尝试过使用DoRec和实现的mfix,

instance Monad  => MonadFix (MyMonad ) where
    mfix f = fix (\mx -> mx >>= f)

事情冻结了.有没有任何方法可以修复我的代码(或者第一次正确设计它的方法),还是应该写一些更直接的东西？

我没有正式的延续知识,我想知道是否有人可以帮助我验证和理解我写的代码:).

问题

我试图解决的一般问题是转换表达式

(2 * var) + (3 * var) == 4

进入功能

\x y -> 2 * x + 3 * y == 4 -- (result)

然后可以将其传递到yices-painless包中.

动机

作为一个更简单的例子,请注意将var其翻译成\x -> x.我们怎样才能乘两个var的(表示他们\x -> x和\y -> y)到一个表达\x -> \y -> x * y？

我听说延续被描述为"计算的其余部分",并认为这就是我所需要的.遵循这个想法,var应该采取一种功能

f :: ? -> E -- rest of computation

其参数将是创建的变量的值var,并返回我们想要的内容(代码列表标记result),一个新函数接受变量x并返回f x.因此,我们定义,

var' …