小编Cac*_*tus的帖子

我有一个封闭式的家庭,没有抓住所有情况:

{-# LANGUAGE TypeFamilies #-}

type family Foo a where
    Foo Bool = Int
    Foo Int = Bool

有没有办法强制类型检查器拒绝以下程序:

data T a = MkT deriving Show

x :: T (Foo String)
x = MkT

由于没有Foo String类型的事实？

我在Haskell有一个任务(不,这不是我的功课,我正在学习考试).

任务是:

写入无点函数numocc,用于计算给定列表中元素的出现次数.例如:numocc 1 [[1, 2], [2, 3, 2, 1, 1], [3]]=[1, 2, 0]

这是我的代码:

addif :: Eq a => a -> Int -> a -> Int
addif x acc y = if x == y then acc+1 else acc

count :: Eq a => a -> [a] -> Int
count = flip foldl 0 . addif

numocc :: Eq a => a -> [[a]] -> [Int]
numocc = map . count

numocc并且count …

对于足够多态的类型,参数可以唯一地确定函数本身(有关详细信息,请参阅Wadler的定理免费!).例如,唯一具有类型的总函数forall t. t -> t是标识函数id.

是否有可能在伊德里斯陈述并证明这一点？(如果在伊德里斯内部无法证明,无论如何都是真的吗？)

以下是我的尝试(我知道函数相等不是Idris中的原始概念,所以我断言泛型类型的任何函数t -> t总是返回与身份函数返回的结果相同的结果):

%default total

GenericEndomorphism: Type
GenericEndomorphism = (t: Type) -> (t -> t)

id_is_an_example : GenericEndomorphism
id_is_an_example t = id

id_is_the_only_example : (f : GenericEndomorphism) -> (t : Type) -> (x : t) -> f t x = x
id_is_the_only_example f t x = ?id_is_the_only_example_rhs

由此产生的洞是:

- + Main.id_is_the_only_example_rhs [P]
 `--                                f : GenericEndomorphism
                                    t : Type
                                    x : t
     -------------------------------------------------------
      Main.id_is_the_only_example_rhs : …

在开发过程中,我一直在elm-reactor测试我的单页Elm应用程序.但是对于生产部署,我想将编译器的输出作为静态文件存储在Web服务器上.

如何将Elm页面编译成一对独立的HTML + Javascript文件？

一些标准的Haskell库是否定义了这样的数据类型

data ListWithEnd e a = Cons a (ListWithEnd e a)
                     | End e

这是一个列表,其终止元素带有指定类型的值？

因此与无限流ListWithEnd ()同构[]并且ListWithEnd Void是同构的.或者,从不同的角度来看,ListWithEnd e a非常接近ConduitM () a Identity e..

请注意以下课程:

class ListIsomorphic l where
    toList    :: l a -> [a]
    fromList  :: [a] -> l a

我也要求toList . fromList == id.如何编写重写规则来告诉GHC进行替换？

我是函数式编程的新手(来自javascript),我很难分辨两者之间的区别,这也搞砸了我对functor与monads的理解.

仿函数:

class Functor f where
    fmap :: (a -> b) -> f a -> f b

Monad(简化):

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

• fmap 接受函数和仿函数,并返回一个仿函数.
• >>= 接受一个函数和一个monad,并返回一个monad.

两者之间的区别在于函数参数:

• fmap - (a -> b)
• >>= - (a -> m b)

>>=获取一个返回monad的函数参数.我知道这很重要,但是我很难看到这个轻微的东西如何使monad比functor强大得多.谁能解释一下？

有没有办法链接功能withCString？我的意思是任何看起来像的功能f :: Foo -> (CFoo -> IO a) -> IO a.

例如,假设有一个功能 cFunc :: CString -> CFoo -> CBar -> IO ()

Usualy,我会做类似的事情:

haskellFunc string foo bar =
  withCString string $ \ cString ->
    withCFoo foo $ \ cFoo ->
      withCBar bar $ \ cBar ->
        cFunc cString cFoo cBar

但我想做的事情如下:

haskellFunc = (withCString |.| withCFoo |.| withCBar) cFunc

与一些合适的组合操作员|.|.

我正在编写带有大量C绑定的库,这个样板经常出现.难道我做错了什么？

我最近有幸学习了一些Idris,我发现非常方便的一件事是!-notation,它让我缩短了do块中的monadic代码,比如

a' <- a
b' <- b
c' <- c
someFunction a' b' c'

更好的

someFunction !a !b !c

现在,当我在Haskell中编写代码时,我正在寻找类似的东西,但据我所知它不存在(并且爆炸字符显然已经用于严格的模式匹配).有没有办法避免在do块中有一堆琐碎的左箭头？也许是一个扩展,它会添加一个重写规则,或者是什么呢？

我正在寻找一个无monad,常量访问查询O(1)关联数组.

考虑假设类型:

data HT k v = ???

我想构建一次不可变结构:

fromList :: Foldable t, Hashable k => t (k,v) -> HT k v

我希望随后以恒定时间访问重复查询::

lookup :: Hashable k => HT k v -> k -> Maybe v

似乎有两个候选图书馆不足:

• unordered-containers

• hashtables

unordered-containers

unordered-containers包含类型的严格和惰性变体HashMap.两者HashMap都有函数记录的O(log n)查询lookup.此查询访问时间似乎是由于HashMap类型的构造,其具有允许O(log n) insert功能的内部树结构.对于许多用例而言,可理解的设计权衡,但由于我不需要可变,HashMap这种权衡妨碍了我的用例.

hashtables

hashtables包含一个HashTable类型类和三个具有不同表构造策略的实例类型.这个库的类型类定义了一个常量时间O(1) lookup函数定义,但它永远嵌入在STmonad中.没有办法"冻结"有状态HashTable实现lookup,并且没有嵌入有状态monad 的函数.当整个计算以状态monad包装时,库的类型类接口设计得很好,但这种设计不适合我的用例.

是否存在一些定义类型和函数的其他库,它们可以构造一个不可嵌入的常量访问查询O(1)关联数组,该数组未嵌入有状态monad中？

是否存在某种方法来包装或修改这些现有的基于散列的库,以生成不嵌入有状态monad …