小编luo*_*990的帖子

我知道该函数sequence可以处理[[1, 2], [3, 4]] -> [[1, 3], [1, 4], [2, 3], [2, 4]]问题.

但我认为真正的笛卡尔积应该处理这个([1, 2], ['a', 'b']) -> [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]问题,如果每个列表的类型不同,外部元组的类型(和大小)也应该关心.

所以,cartProd我想要的函数有这样的类型:([a1], [a2], [a3] ...) -> [(a1, a2, a3 ...)]

我知道类型系统存在一些问题.但有没有办法实现这个完美版本cartProd？

AFAIK，有两种方法可以获取调用堆栈以在Haskell中进行调试：

1. HasCallStack在代码中添加约束
2. 用编译代码 ghc -prof -fprof-auto-top

我的测试代码：

import GHC.Stack

-- | a wrapper function to make "last" from base traceable
last' :: HasCallStack => [a] -> a
last' xs = case xs of [] -> error "abuse last"; _ -> last xs

-- | a untraceable partial function
foo :: [Int] -> Int
foo xs = last' xs + 1

-- | a untraceable partial function
-- , which looks like traceable, but it's call stack is cut off …

该哈斯克尔工具集是目前最流行的Haskell包管理器，现在，它的主要目标是使大厦哈斯凯尔包重复性。

但是堆栈方法的目标是找到一个巨大的无冲突包修订集，并将其称为snapshot. 通过这种方式，包维护者被推送更新他的包的依赖项，这样它就不会与最近的snapshot.

我不得不说，这个设计太理想了，无法在现实世界中工作。

相比之下，NPM（NodeJS 的包管理器）通过一种更实用的方式来实现这个目标：它允许冗余。在钻石依赖的情况下，例如a -> b, c; b -> d(v1); c -> d(v2)，NPM 只需d为b和分别安装两个不同的版本c。这样，使用包的用户就可以像黑盒一样依赖包，无需考虑依赖之间是否存在冲突的深度依赖。

我想知道为什么 Stack 的设计不允许对包进行冗余修订是否有一些实际的原因。是否可以为 Haskell 实现这样的包管理器？它的实施中最困难的部分是什么？

该查询大多数情况下会在 10 秒内返回，但有时需要 40 秒或更长时间。

swarm中有两个执行器节点，两个节点的配置文件没有显着差异，以下是其中之一：

      HDFS_SCAN_NODE (id=0):(Total: 39s818ms, non-child: 39s818ms, % non-child: 100.00%)
     - AverageHdfsReadThreadConcurrency: 0.07 
     - AverageScannerThreadConcurrency: 1.47 
     - BytesRead: 563.73 MB (591111366)
     - BytesReadDataNodeCache: 0
     - BytesReadLocal: 0
     - BytesReadRemoteUnexpected: 0
     - BytesReadShortCircuit: 0
     - CachedFileHandlesHitCount: 0 (0)
     - CachedFileHandlesMissCount: 560 (560)
     - CollectionItemsRead: 0 (0)
     - DecompressionTime: 1s501ms
     - MaterializeTupleTime(*): 11s685ms
     - MaxCompressedTextFileLength: 0
     - NumColumns: 9 (9)
     - NumDictFilteredRowGroups: 0 (0)
     - NumDisksAccessed: 1 (1)
     - NumRowGroups: 56 (56)
     - NumScannerThreadMemUnavailable: 0 (0)
     - NumScannerThreadReservationsDenied: …

考虑一个接受Set的函数,并返回其字节长度,命名为byteLength:

byteLength : Set -> Maybe Nat

如果我想直接实现这个函数,我需要在类型参数上进行模式匹配:

byteLength Char = Just 1
byteLength Double = Just 8
byteLength _ = Nothing

但由于不允许在Set/Type上进行模式匹配,因此上述代码无法编译.

所以我们必须将接口定义为变通方法

Interface ByteLength a where
    byteLength : Nat

implement ByteLength Char where
    byteLength = 1

并且以更一般的方式,也许我们可以使用TypeRep之类的东西在TypeRep上执行类似的事情和模式匹配.但TypeRep也被定义为接口.

我认为使用Interface和使用forall是非常不同的,因为Interface意味着"对于某些类型",而forall意味着"适用于所有类型".

我想知道为什么这些DT语言不支持Set/Type上的模式匹配,是否有一些我不知道的特殊原因？

我在读包的文档异步，并试图找到类似于JavaScript的承诺的东西，我觉得Concurrently，这是最贴近的概念，实现Functor，Applicative（Promise.all），Alternative（Promise.race）。但是它没有实现Monad（Promise.then），我想知道为什么。

我认为这可能是因为(>>=)是顺序操作，与名称冲突Concurrently，但这是唯一的原因吗？这里还有更重要的原因吗？

我想在我的Expr定义中捕获类型有效性,并且在我定义时会出现问题Add,预期后面会有参数Decimal或Whole参数,但我不知道如何模式匹配它们.以下是我的试验:

第一次试用:

data DataType = Text | Decimal | Whole

data Expr : DataType -> Type where
    Add : (Expr Decimal) -> (Expr Decimal) -> Expr Decimal
    Add : (Expr Whole) -> (Expr Whole) -> Expr Whole

第二次试用:

data DataType = Text | Decimal | Whole

data Expr : DataType -> Type where
    Add : (Expr ty) -> (Expr ty) -> Expr ty

第3次试用:

data DataType = Text | Decimal | Whole …

我正在尝试定义自己的Show名为 的类MyShow，并希望从TextShow 和 中“窃取”实例Prelude.Show，并且如果两者都存在，则更喜欢前一个。

我尝试了以下操作（showbPrec事情被简化以集中精力）：

{-# LANGUAGE UndecidableInstances #-}

import Data.Text (Text, pack, unpack)
import qualified Prelude as P
import qualified TextShow as T

class MyShow a where
    showText :: a -> Text

instance {-# OVERLAPPING #-} TextShow a => MyShow a where
    showText x = T.showt x

instance {-# OVERLAPPABLE #-} P.Show a => MyShow a where
    showText x = pack (P.show x)

但我被告知不允许重复实例声明Show，那么有什么方法可以定义我自己的实例并重用其他人的实例吗？

我们不能以无限精度存储小数,但可能有某种方式来表示它们就像我们在haskell中表示无限列表一样.

我想到的第一个想法是通过类似于Codata的东西来表示十进制数,因此对于任何给定的自然数k,我们可以将精确的十进制数计算为k位.

但有一些明显的问题,想想数a = 0.333...和b = 0.666...,如果我们加在一起,我们得到了ans = 0.999...(数字序列),但我们永远无法知道是否a + b == 1在这种情况下.

我要的是,以某种方式定义十进制数,使之支持+,-,*,/,>,==运营,不管是什么+,-,*,/我们应用到这些十进制数字操作,我们得到新的十进制数,我们可以计算出它们给定任何自然数k精确到k位数.

我想知道:有什么想法可以解决这个问题吗？

是否有任何表达式QUARTER,WEEK以及DAYOFWEEKHive(v0.14.1)中的DateTime字段与MySql中的这些buildin函数做同样的事情？

这是我想要的规范(来自MySql doc):

季度 WEEK DAYOFWEEK

注意:1.函数quarter()是在Hive 1.3中引入的,但是我需要一个expr来支持更低版本.2.支持函数weekofyear()而不是week(),但是有一点不同.但没关系,所以请忽略这个.

当我们在nodejs中使用Promise时,给定Promise p,我们无法通过在"then"回调中记录currentTime来知道Promise p何时实际解析.

为了证明这一点,我在下面编写了测试代码(使用CoffeeScript):

# the procedure we want to profile
getData = (arg) ->
    new Promise (resolve) ->
        setTimeout ->
            resolve(arg + 1)
        , 100

# the main procedure
main = () ->
    beginTime = new Date()
    console.log beginTime.toISOString()
    getData(1).then (r) ->
        resolveTime = new Date()
        console.log resolveTime.toISOString()
        console.log resolveTime - beginTime
    cnt = 10**9
    --cnt while cnt > 0
    return cnt

main()

运行上面的代码时,您会注意到resolveTime(代码运行到回调函数的时间)远远超过了beginTime的100ms.

所以如果我们想知道Promise何时实际解决了,怎么样？

我想知道确切的时间,因为我正在通过日志记录进行一些分析.当我在黑盒子外面进行一些分析时,我无法修改Promise p的实现.

那么,是否有一些函数,如promise.onUnderlyingConditionFulfilled(回调),或任何其他方式来实现这一点？