小编HTN*_*TNW的帖子

虽然我经常在我的Ubuntu机器上使用Hadoop,但我从未想过SUCCESS和part-r-00000文件.输出总是驻留在part-r-00000文件中,但文件的用途是SUCCESS什么？为什么输出文件有名字part-r-0000？是否有任何意义/任何命名法或者这只是随机定义的？

我可以stack build从命令行创建一个项目,但是当我尝试C-c C-l使用emacs(带(custom-set-variables '(haskell-process-type 'stack-ghci)))时,我得到一个错误,即我导入的所有包模块都找不到.

/home/amcp011/bec/amcp011/accelerate/gpe/src/Numeric/GPE/Utils.hs:30:1: error:
    Failed to load interface for ‘Data.Array.Accelerate’
    Locations searched:
      Data/Array/Accelerate.hs
      Data/Array/Accelerate.lhs
      Data/Array/Accelerate.hsig
      Data/Array/Accelerate.lhsig
      /home/amcp011/bec/amcp011/accelerate/gpe/src/Data/Array/Accelerate.hs
      /home/amcp011/bec/amcp011/accelerate/gpe/src/Data/Array/Accelerate.lhs
      /home/amcp011/bec/amcp011/accelerate/gpe/src/Data/Array/Accelerate.hsig
      /home/amcp011/bec/amcp011/accelerate/gpe/src/Data/Array/Accelerate.lhsig

gpe.cabal:

build-depends:       base >= 4.7 && < 5
                   , bytestring
                   , bytestring-conversion
                   , mtl
                   , time
                   , filepath
                   , directory
                   , accelerate
                   , accelerate-io

stack.yaml:

extra-deps: [accelerate-1.0.0.0
            ,accelerate-io-1.0.0.0
            ]

我正在试验Coq对Haskell的提取机制。我在Coq中为质数写了一个幼稚的谓词，它是：

(***********)
(* IMPORTS *)
(***********)
Require Import Coq.Arith.PeanoNat.

(************)
(* helper'' *)
(************)
Fixpoint helper' (p m n : nat) : bool :=
  match m,n with
  | 0,_ => false
  | 1,_ => false
  | _,0 => false
  | _,1 => false
  | S m',S n' => (orb ((mult m n) =? p) (helper' p m' n))
  end.

(**********)
(* helper *)
(**********)
Fixpoint helper (p m : nat) : bool :=
  match m with
  | 0 => false …

我有这种类型：

struct immobile {\n   // other stuff omitted\n   immobile(immobile&) = delete;\n   immobile(immobile&&) = delete;\n};\nimmobile mk_immobile();\n// e.g. this compiles\n// mk_immobile() is a prvalue and i is its result object\nimmobile i(mk_immobile());\n

我也有这个类模板：

template<typename T>\nstruct container {\n    std::variant<T, other_stuff> var;\n    template<typename... Args>\n    container(Args&&... args)\n    : var(std::in_place_index<0>, std::forward<Args>(args)...) {}\n};\n

我想container围绕 生成的对象构造mk_immobile()，该immobile对象用于初始化 的变体之一var。

container<immobile> c(mk_immobile());\n

然而，这是行不通的。其一，std::variant的构造函数要求std::is_constructible_v<immobile, immobile>，但它不成立。更糟糕的是，即使这个简化版本也失败了：

template<typename T>\nstruct demonstration {\n    T t;\n    template<typename... Args>\n    demonstration(Args&&... …

我刚读完“学到Haskell来造福伟大！”。书，所以我的问题可能很幼稚。我不明白的是如何从纯代码中调用“不纯”的IO函数。

这是一个用C＃编写的工作示例。在我们的业务逻辑中，我们根据天气计划一些行动。我们以通常的C＃方式进行操作。

interface IWeatherForecast
{
    WeatherData GetWeather(Location location, DateTime timestamp);
}

// concrete implementation reading weather from DB
class DbWeather : IWeatherForecast
{
    public override WeatherData GetWeather(Location location, DateTime timestamp)
    {...}
}

class WeatherFactory
{
    public IWeatherForecast GetWeatherProvider()
    {...}
}

// Business logic independent from any DB
class MaritimeRoutePlanner
{
    private IWeatherForecast weatherProvider = weatherFactory.GetWeatherProvider();

    public bool ShouldAvoidLocation(Location location, DateTime timestamp)
    {
        WeatherData weather = weatherProvider.GetWeather(location, timestamp);
        if(weather.Beaufort > 8)
            return true;
        else...
            ...
    }
}

如何在Haskell中实现此逻辑？

实际上，“纯逻辑” MaritimeRoutePlanner称之为weatherProvider.GetWeather() …

I have the following toy implementation of a non-empty list (NEList) datatype:

-- A type to describe whether or not a list is empty.
data Emptiness :: Type where
  Empty    :: Emptiness
  NotEmpty :: Emptiness

-- The list itself. Note the existential type in `Cons'.
data List :: Emptiness -> Type -> Type where
  Nil :: List 'Empty a
  Cons :: a -> List e a -> List 'NotEmpty a

type EList a = List 'Empty a
type …

也就是说，这样的事情总是合法的吗？

struct Derived;
struct Base { Base(Derived*); };
struct Derived : Base { Derived() : Base(this) { } };
Base::Base(Derived *self) {
    if(static_cast<Base*>(self) != this) std::terminate();
}

int main() {
    Derived d; // is this well-defined to never call terminate?
}

在static_cast求值时，self还没有指向一个Derived对象——那个对象正在构建中。例如，如果Derived有数据成员，它们的构造函数就不会被调用。是否仍然保证强制转换是定义的行为，从而产生一个与Base's等效的指针this（它确实指向一个完全构造的Base基类子对象）？

我认为接近回答这个问题的标准引语是[conv.ptr]/3。

...转换的结果是一个指向派生类对象的基类子对象的指针。...

但我认为是没有派生类对象还没有，那么会发生什么？如果它确实是未定义的，答案会改变self != static_cast<Derived*>(this)吗？

（Clang 和 GCC 编译并“按预期”运行。）

我有Haskell代码需要与C库接口,有点像这样:

// MyObject.h
typedef struct MyObject *MyObject;
MyObject newMyObject(void);
void myObjectDoStuff(MyObject myObject);
//...
void freeMyObject(MyObject myObject);

原始的FFI代码将所有这些函数包装为纯函数unsafePerformIO.这导致了错误和不一致,因为操作的顺序是不确定的.

我正在寻找的是一种处理Haskell中的对象而不诉诸于所有内容的一般方法IO.什么是好的是我可以做的事情,如:

myPureFunction :: String -> Int
-- create object, call methods, call destructor, return results

有没有一个很好的方法来实现这一目标？

我希望能够cata从recursion-schemes包中使用Church编码中的列表.

type ListC a = forall b. (a -> b -> b) -> b -> b

为方便起见,我使用了二级排序,但我不在乎.newtype如果您觉得有必要,请随意添加,使用GADT等.

教会编码的概念众所周知且简单:

three :: a -> a -> a -> List1 a 
three a b c = \cons nil -> cons a $ cons b $ cons c nil

基本上是"抽象未指定" cons,nil而不是"正常"构造函数.我相信一切都可以用这种方式编码(Maybe树木等).

很容易证明它List1与普通列表确实是同构的:

toList :: List1 a -> [a]
toList f = f (:) []

fromList :: [a] -> List1 a
fromList …

我正在使用Netwire编写一个由来自网络的事件驱动的程序.我想这里有三个问题:

1. 是什么让人Control.Wire.Unsafe.Event不安全？就像标题所说,我需要保持哪些不变量才能安全使用它？

2. 我觉得我需要这样的东西:mapMaybeE :: Monad m => (a -> Maybe b) -> Wire s e m (Event a) (Event b).上下文是我有来自网络的消息,我想只响应其中一些消息.这就是我写的:

   mapMaybeE :: Monad m => (a -> Maybe b) -> Wire s e m (Event a) (Event b)
   mapMaybeE f = arr go . arr (fmap f)
     where go WU.NoEvent = WU.NoEvent
           go (WU.Event Nothing) = WU.NoEvent
           go (WU.Event (Just a)) = WU.Event a
   

   Run Code Online (Sandbox Code Playgroud)

   这是"合法的"吗？或者如果没有事件,我是否应该禁止？

3. Netwire对这类问题有意义吗？我见过的所有例子都是不断循环的游戏.在这里,我只想在有事情要做的时候踩电线.大多数情况下,这将是网络事件,但我可能也想在计时器上做事情.例如,一个事件进入,然后五秒钟后程序执行某些操作.它不应该连续循环,直到会话中的时间比事件进入的时间大5秒.