我正在阅读Source Making网站,特别是Refactoring部分.在描述长方法问题的页面上,出现以下语句:

较旧的语言在子程序调用中带来了开销,这阻碍了人们使用小方法.现代OO语言几乎消除了进程内调用的开销.

我只是想知道现代OO是如何做到这一点的,与"旧"方式相比如何呢？

如果我为具有一系列语句的类c语言编写语法,那么定义语法的最标准方法是什么？

我的想法是做这样的事情:

<program> ::= <statement>
<statement> ::= <statement-head><statement-tail>
<statement-head> ::= <if-statement> | <var-declaration> | <assignment> | <whatever>
<statement-tail> ::= ; | ;<statement>

但这对我来说感觉有点笨拙.我也考虑过制作

<program> ::= <statement>*

要么

<statement> ::= <statement-head> ; | <sequence>
<sequence>  ::= <statement> <statement>

类型制作.

是否有标准或可接受的方式来执行此操作.我希望我的AST尽可能干净.

我正在为我正在写的翻译添加协程支持,我想做类似以下的事情:

typedef enum {
    bar_stuff,
    bar_other
    } Bar;

typedef enum {
    foo_error=-1,
    foo_none=0,
    foo_again
    } Foo_state;

Foo_state do_foo(Bar bar,Foo_state foo)
    {
    switch(foo)
        {
        case foo_none: //start
        switch(bar)
            {
            case bar_stuff:
                //do stuff
                return foo_none;
            case bar_other:
                //do other stuff
                return foo_again;
                case foo_again: //!! this doesn't work
                    /* edit: this is supposed to be a case of
                     *     switch(foo), not switch(bar)
                     */
                //do more other stuff
                return foo_none;
            default:
                //stuff
                return foo_none;
            }
        default:
            //fail
            return foo_error;
        }
    }

显然这不起作用(我得到重复的案例值,替代可能是未定义的行为/段错误).我可以将switch(bar)写为if/else …

我想弄清楚哪种方式是用不同语言提供asp经典页面的最佳方法.页面上的一些内容是在服务器端生成的,有些是硬编码的html.我想创建一个下拉列表,在不同语言之间进行选择,以便服务器端生成的html以及硬编码页面内容发生变化.

谢谢!

最近有一些关于静态类型约束和内联的问题:

1. 在F#中使用`inline`
2. F#如何编译可以将多种不同参数类型带入IL的函数？

特别是两个陈述让我印象深刻:

1. "有没有办法来编码在.NET编译代码一流的方式这种类型的限制.然而,F#编译器可以在它内联函数,使所有运营商使用在编译时解析的现场强制执行这一约束".

2. "...但是F#也可以在编译的程序集之间内联,因为内联是通过.NET元数据传达的."

后者几乎似乎与前者相矛盾.我想知道为什么内联需要与静态类型约束功能相关.不能在F#编译器的工作方式(我相信)C++模板和泛型.NET做,并根据需要在编译时动态生成特定的类型,可重复使用的功能呢？

例如:

多态定义:

let add (lhs:^a) (rhs:^a) = lhs + rhs

用法:

let a = add 2 3
let b = add 2. 3.
let b = add 4. 5.

编译器生成的添加功能:

let add_int (lhs:int) (rhs:int) = lhs + rhs
let add_float (lhs:float) (rhs:float) = lhs + rhs

编译器重写用法:

let a = add_int 2 3
let b = add_float 2. 3.
let c = add_float 4. 5.

我不是编译器作家也不是语言设计师,虽然这些主题对我很感兴趣,所以请指出我的天真.

最近我的大学为本科生设置了大型项目.其中一个项目是创建一种新的编程语言,其中包含其他语言的所有最理想的部分.现在,我知道很多事情对我来说是非常不可行的(或者甚至是密切的) - 例如,使语言非常接近自然语言.

有一些很好的功能,如高阶函数和交换两个变量值的运算符.然而,我很难想到很多,所以一些建议将非常感激 - 最好的建议被标记为答案.我只是在这里寻找想法,而不是如何实现它们的方法.

for i in mylist:
    process(i)

[process(j) for j in mylist]

在执行结束,i并j留在命名空间的最后一个值mylist.

除了创建一个隐藏i泄漏的专门功能; 隐藏循环索引的其他方法是什么？

我确实理解ODR所说的内容,但我不明白它试图实现的目标.

我看到违反它的两个后果 - 用户将得到语法错误,这是完全正常的.并且可能存在一些致命的错误,并且用户将是唯一一个有罪的人.

作为违反ODR并获得致命错误的例子,我想像这样:

a.cpp

struct A
{
        int a;
        double b;
};
void f(A a)
{
        std::cout << a.a << " " << a.b << std::endl;
}

main.cpp中

struct A
{
        int a;
        int b;

};
void f(A a);

int main()
{

        A a = {5, 6};
        f(a);

        return 0;
}

如果示例与ODR无关,请纠正我.

那么,ODR是否试图禁止用户做这些有害的事情？我不这么认为.

是否试图为编译器编写者设置一些规则,以避免潜在的危害？可能不会,因为大多数编译器都没有检查ODR违规.

还有什么？

以下摘录自cppreference链接1和cppreference链接2:

enum codecvt_mode
{
    consume_header = 4,
    generate_header = 2,
    little_endian = 1
};

template
<
    class Elem,
    unsigned long Maxcode = 0x10ffff,
    std::codecvt_mode Mode = (std::codecvt_mode)0
>
class codecvt_utf8_utf16 : public std::codecvt<Elem, char, std::mbstate_t>;

显然,0枚举类型的定义不明确codecvt_mode.C++标准可能会故意保留实现定义的默认值.

但是,我认为实现定义的默认值对用户来说可能是模糊的.

为什么C++ 11定义

std::codecvt_mode Mode = (std::codecvt_mode)0

而不是

std::codecvt_mode Mode = std::little_endian

？

Python是鸭子类型,通常这可以避免在处理原始对象时使用faff.

典型的例子(以及名称背后的原因)是鸭子测试:如果它看起来像鸭子,像鸭子一样游泳,像鸭子一样呱呱叫,那么它可能是一只鸭子.

然而一个值得注意的例外是dict键/值,它看起来像一只鸭子,像鸭子一样游泳,但特别是不像鸭子那样嘎嘎叫.

>>> ls = ['hello']
>>> d = {'foo': 'bar'}
>>> for key in d.keys():
..      print(key)
..
'foo'
>>> ls + d.keys()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "dict_keys") to list

有人可以告诉我为什么这是？