12

我正在尝试将 mocha 绑定写入 PureScript 并且完全被Control.Monad.Eff

describe(function(){
  //do stuff  
});

Describe 是一个不接受任何内容并返回 IO 或 Eff 或其他含义的函数（副作用发生没有返回值）。

到目前为止我的尝试

foreign import describe 
  "function describe(n){         \
  \ return function(){           \
  \   window.describe(n); \
  \ };                           \  
  \}" :: forall eff a. Eff eff a -> Eff eff

foreign import describe "describe" :: forall eff a. Eff eff a -> Eff eff
foreign import describe "describe" :: Eff -> Eff
foreign import describe "describe" :: forall eff a. (a -> Eff eff) -> Eff eff

显然在这里遗漏了一些东西。请帮忙。

4

1 回答 1

14

PureScript 的外部函数接口其实很简单。例如，假设您有以下 JavaScript 函数：

function si(p) {
    return function (r) {
        return function (t) {
            return p * r * t / 100;
        };
    };
}

您可以按如下方式导入它：

foreign import si :: Number -> Number -> Number -> Number

您还可以按如下方式内联该函数：

foreign import si
    "function si(p) {\
    \    return function (r) {\
    \        return function (t) {\
    \            return p * r * t / 100;\
    \        };\
    \    };\
    \}" :: Number -> Number -> Number -> Number

对于副作用，PureScript 不使用IOmonad。相反，它使用了Effmonad。

据我了解，单子与带有额外类型参数Eff的单子相同：一排效果。IO

例如，在 Haskell 中，print函数具有以下类型：

print :: Show a => a -> IO ()

在 PureScript 中，该print函数具有以下类型：

print :: Show a => a -> Eff (trace :: Trace | r) Unit

那么我们从中了解什么呢？

  1. IO类似于Eff ewheree是一排效果。
  2. Unit类似于()。
  3. 该print函数具有trace类型的效果Trace。
  4. 此外，该print功能可以与其他效果相结合。行多态性。这意味着它是可组合的。

Eff值本身称为动作。例如print "Hello World!"，类型Eff (trace :: Trace | r) Unit是动作。

作为函数参数的Eff值称为处理程序。它可以被认为是一个没有参数的高阶有效函数。

Eff没有副作用的值称为纯值：

type Pure a = forall e. Eff e a
runPure :: Pure a -> a

由于效果行（即e）是多态的（或者换句话说是空的，一个黑洞），PureScript 假定该函数没有副作用。然而，这也意味着它可以与其他有效的功能组合。

monad 是程序员和编译器之间的Eff契约，其中程序员向编译器承诺给定的Eff值将仅具有规定的一行效果，而不再具有其他效果。

来到你的describe功能：

Describe 是一个不接受任何内容并返回 IO 或 Eff 或其他含义的函数（副作用发生没有返回值）。

其实这是错误的。您的describe函数确实将函数作为参数：

describe(function(){
  //do stuff
});

此外，它接受的函数没有参数，这意味着它是一个有效的函数。因此，它必须是Eff e awheree并且a可以是任何一行效果和任何返回值的类型。

因此，您的描述函数必须是以下类型：

describe :: Eff e a -> Eff (describe :: Describe | e) {}

在 Haskell 中，它会这样写：

describe :: IO a -> IO ()

PureScript 比 Haskell 更明确。无论如何，Describe这是您创建的一种新效果类型，它与其他效果类型不同，例如Trace：

foreign import data Describe :: !

describe然后，您将按如下方式导入：

foreign import describe
    "function describe(f) {\
    \    return function () {\
    \        window.describe(f);\
    \    };\
    \}" :: forall e a. Eff e a -> Eff (describe :: Describe | e) {}

最后，您可以按如下方式使用它：

main = do
    describe $ print "Hello World!"

整个代码如下：

module Main where

import Control.Monad.Eff
import Debug.Trace

foreign import data Describe :: !

foreign import describe
    "function describe(f) {\
    \    return function () {\
    \        window.describe(f);\
    \    };\
    \}" :: forall e a. Eff e a -> Eff (describe :: Describe | e) {}

main = do
    describe $ print "Hello World!"

它将生成以下 JavaScript：

var PS = PS || {};

PS.Main = (function () {
    "use strict";

    var Prelude = PS.Prelude;
    var Debug_Trace = PS.Debug_Trace;

    function describe(f) {
        return function () {
            window.describe(f);
        };
    }

    var print = Debug_Trace.print(Prelude.showString({})); 

    var main = describe(print("Hello World!"));

    return {
        main: main, 
        describe: describe
    };
}());

希望有帮助。

于 2014-07-14T04:31:39.377 回答