小编Aad*_*hah的帖子

我试图通过在Haskell中实现它来了解镜头.我已经实现了view如下组合器:

{-# LANGUAGE RankNTypes #-}

import Control.Applicative
import Data.Traversable

type Lens s a = Functor f => (a -> f a) -> s -> f s

view :: Lens s a -> s -> a
view lens = getConst . lens Const

但是,当我尝试与它一起使用时,traverse我收到以下错误消息:

Prelude> :load Lens.hs
[1 of 1] Compiling Main             ( Lens.hs, interpreted )
Ok, modules loaded: Main.
*Main> :t view traverse

<interactive>:1:6:
    Could not deduce (Applicative f) arising from a use of ‘traverse’
    from …

Java Socket类有两种方法isClosed,isConnected分别检查套接字是关闭还是连接.我想知道一个只打开的TCP套接字和一个打开并连接的TCP套接字有什么区别,这与UDP有什么不同.

我想知道重写方法与原型和没有原型之间的区别.考虑:

例1:

function Animal() {
    this.sleep = function () {
        alert("animal sleeping");
    };

    this.eat = function () {
        alert("animal eating");
    };
}

function Dog() {
    this.eat = function () {
        alert("Dog eating");
    };
}

Dog.prototype = new Animal;

var dog = new Dog;

dog.eat();

例2:

function Animal() { }

function Dog() { }

Animal.prototype.sleep = function () {
    alert("animal sleeping");
};

Animal.prototype.eat = function () {
    alert("animal eating");
};

Dog.prototype = new Animal;

Dog.prototype.eat = function () {
    alert("Dog eating"); …

注意:

正如答案所说,由于问题和我的评论中描述的一些问题,问题中提出的代码并没有真正实现继承(否则它会成为答案而不是问题......).它可以像预期的那样继承假(甚至不是原型).

• 摘要

  简而言之,使它类似于我们编写一般的OO语言而不是javascript,但保持继承是正确的.

• 故事

  的Object.create是实现原型继承的好方法,但它是一个有点混乱,以一个类型的大脑和新的球迷.

  我们可以通过各种方式编写javascript代码,就像我们使用伪经典模式编写其他OO语言一样.因为它是伪经典的,我们必须正确处理javascript的底层原型继承.

  我想要找到的是一种可以在类声明上实现伪古典继承的方法.演示代码放在帖子的后面,它按预期工作,但是,有一些烦人的事情:

  1. 我无法摆脱return类声明或继承不起作用.

  2. 除了传入this类声明以使返回的闭包知道是什么,我没办法this.

  3. 我也想摆脱function (instance, _super) {,但还没有一个好主意.

  4. 不继承类的静态(自己的属性).

  解决方案比现有框架更多的是一些语法糖,一个好的模式是适用的.

该_extends函数:

function _extends(baseType) {
    return function (definition) {
        var caller=arguments.callee.caller;
        var instance=this;

        if(!(instance instanceof baseType)) {
            (caller.prototype=new baseType()).constructor=caller;
            instance=new caller();
        }

        var _super=function () {
            baseType.apply(instance, arguments);
        };

        definition(instance, _super);
        return instance;
    };
}

本Abc类:

function Abc(key, …

您可以使用解构分配来定义ES6中的枚举,如下所示:

var [red, green, blue] = [0, 1, 2];

相反,我希望解构分配的右侧是动态的.例如:

var MAX_ENUM_SIZE = 32;
var ENUM = new Array(MAX_ENUM_SIZE);
for (var i = 0; i < MAX_ENUM_SIZE; i++) ENUM[i] = i;

var [red, green, blue] = ENUM;

不幸的是,这似乎是一个黑客.如果我希望将来有更大的枚举怎么办？因此,我正在考虑使用迭代器进行解构赋值,如下所示:

var [red, green, blue] = enumeration(/* I don't want to specify size */);

但是,我不认为可以使用迭代器进行解构赋值^{[需要引证]}.有没有办法实现这个目标？

我curry在JavaScript中编写了一个简单的函数,可以在大多数情况下正常工作

const add = curry((a, b, c) => a + b + c);

const add2 = add(2);

const add5 = add2(3);

console.log(add5(5));

<script>
const curried = Symbol("curried");

Object.defineProperty(curry, curried, { value: true });

function curry(functor, ...initArgs) {
    if (arguments.length === 0) return curry;

    if (typeof functor !== "function") {
        const value = JSON.stringify(functor);
        throw new TypeError(`${value} is not a function`);
    }

    if (functor[curried] || initArgs.length >= functor.length)
        return functor(...initArgs);

    const result = (...restArgs) => curry(functor, ...initArgs, ...restArgs);

    return …

我正在尝试使用以下方法建立减法,加法,除法,乘法和其他操作:

1. incr(x) - 一旦调用此函数,它将x + 1分配给x
2. assign(x,y) - 此函数将y的值赋给x(x = y)
3. 零(x) - 此函数将0分配给x(x = 0)
4. 循环X {} - 括号内的操作将执行X次

使用以下规则,可以直接实现这样的添加(添加):

ADD (x, y) {
 loop X {
   y = incr (y)
 }
return y
}

但是,我正在努力实现减法.我认为所有其他所需的操作都可以使用减法完成.

任何提示都将非常感激.

一些实例Category也是实例Functor.例如:

{-# LANGUAGE ExistentialQuantification, TupleSections #-}

import Prelude hiding (id, (.))
import Control.Category
import Control.Arrow

data State a b = forall s. State (s -> a -> (s, b)) s

apply :: State a b -> a -> b
apply (State f s) = snd . f s

assoc :: (a, (b, c)) -> ((a, b), c)
assoc (a, (b, c)) = ((a, b), c)

instance Category State where
    id = State (,) ()
    State g …

第三诫中的小策士指出:

在构建列表时,描述第一个典型元素,然后将其纳入自然递归.

"自然递归"的确切定义是什么？我问的原因是因为我正在接受Daniel Friedman的编程语言原则课程,以下代码不被认为是"自然递归":

(define (plus x y)
    (if (zero? y) x
        (plus (add1 x) (sub1 y))))

但是,以下代码被认为是"自然递归":

(define (plus x y)
    (if (zero? y) x
        (add1 (plus x (sub1 y)))))

我更喜欢"非自然递归"代码,因为它是尾递归的.但是,这样的代码被认为是诅咒.当我问到为什么我们不应该以尾递归形式编写函数时,副教师简单地回答说:"你不要乱用自然递归."

以"自然递归"形式编写函数有什么好处？

Administrative Normal Form是代码的中间表示,适合编译器使用,逻辑上等同于单静态分配但具有一些优点.例如,检查程序是否是有效的SSA表单是关于通过图表的可能路径集合的存在性问题.但是,检查程序是否是有效的ANF表达式只是本地语法的问题.

从严格的功能代码生成ANF非常容易,但我有兴趣从包含变量更新,循环等的命令式代码生成ANF.

有简单的算法将SSA转换为ANF.但是,如果您想快速生成SSA,那么首先生成SSA会变得非常重要.看起来直观的是,如果你想要的是更简单,更透明的格式,那么直接生成它而不是通过更不透明的形式应该更有效.

是否有已发布的算法直接从命令式代码生成ANF？