小编The*_*kle的帖子

可能重复:
{} while(0)在宏中如何工作？

此博客文章的示例:

#define VTAILQ_INSERT_BEFORE(listelm, elm, field) do {              \
    (elm)->field.vtqe_prev = (listelm)->field.vtqe_prev;            \
    VTAILQ_NEXT((elm), field) = (listelm);                          \
    *(listelm)->field.vtqe_prev = (elm);                            \
    (listelm)->field.vtqe_prev = &VTAILQ_NEXT((elm), field);        \
} while (0)

我遇到过其他人,但这个突出了我的意思

如果类型($)是(a -> b) -> a -> b,那么为什么你可以把它作为咖喱($2)？2不是类型(a -> b).见下面的例子.

map ($2)[(+1),(+2)]

这是合法的,令人敬畏的,直觉上有意义.请告诉我它是如何与类型系统规则一致的？

干杯

我一直想要进入一种纯OO语言一段时间,但是我觉得他们似乎都需要一个IDE,我找不到任何不在视频中的好教程格式.

我很高兴以后使用IDE ,但我不想通过一个学习语言.我正在寻找的是一个简单的控制台解释器或命令行编译器,如gcc,ghc,ghci和python IDLE(是的,它是一个IDE,但它是如此极简主义,它可能只是一个命令行解释器).我发现当我不想同时使用IDE时,我会更快,更好,更全面地学习语言.所以,请不要告诉我吱吱声是唯一的方法:P

我也在寻找以文本而非视觉方式呈现的教程.再一次,当我盯着一个页面并且一遍又一遍地阅读别人的咒语时,我会更快地学习,而不是暂停视频,将其取回10秒,按下播放,再次执行,再次,然后再次.

我对不同程度的OO纯度的各种语言感兴趣,我计划在某些时候学习它们.任何一个smalltalk方言都让我感兴趣,Self(一个极端原型导向的smalltalk版本(非常有趣,越激进越好的imo)),strongtalk,vanilla smalltalk(或者一些实现,就像你能得到的那样).

我也对Eiffel感兴趣,我见过的代码片段看起来非常优雅,我读到它实际上非常具有创新性(引入代码合同和其他类似的东西).然而,我会优先考虑来自小型营地的一种语言而不是埃菲尔一侧的语言,因为面对价值的埃菲尔似乎是OO和命令式编程之间的混合体.同样,我宁愿避免Scala(混合OO和功能)和其他混合语言.所以没有C#,Java,C++,D,python等等.我不是在考虑这些语言,因为我认为它们很糟糕,只是因为我开始学习纯OO而且那些语言是混合OO:不是真的是我在找什么.

此外,任何人都可以推荐官方书籍吗？对于smalltalk,有"蓝皮书"AKA"Smalltalk-80:语言及其实现".对艾菲尔来说,有"艾菲尔:语言".我问,因为根据我的经验,你可以通过阅读该语言作者撰写的书籍(参见K&R C编程语言)以及阅读一般书籍来学到很多东西.

所以,是的,我的问题:开始使用纯OO语言会有什么好处？如何在不使用IDE的情况下学习它？是否有一本由语言作者撰写的相关书籍？

作为练习,我试图手动实现前奏的有趣部分.每当我发现有机会自由点我就接受它.然而,这让我在最不可能的地方找到了一堵砖墙.使用此代码:

myelem _ [] = False 
myelem x y  = if x == head y then True else myelem x (tail y)

我正在努力实施notElem.以下是我的尝试:

-- First
mynotelem = not myelem

由于不匹配的类型,可以理解地爆炸.这很容易解决:

-- Second
mynotelem x y = not (myelem x y)

然而,参数x和y的显式声明感觉很丑陋和不必要,所以我试着让它恢复到点自由风格.

-- Third
mynotelem = not $ myelem

哪个失败了

 Couldn't match expected type `Bool'
         with actual type `a0 -> [a0] -> Bool'
 In the second argument of `($)', namely `myelem'
 In the expression: not $ myelem
 In an …

将实现引用透明方法作为静态只读Func而不是简单地作为方法,是否有任何性能影响？我个人认为Func版本更具可读性,但传统方式可能更有效.

这个:

static readonly Func<DateTime, DateTime> TruncateDay =
  date => date.AddHours(-date.Hour)
              .AddMinutes(-date.Minute)
              .AddSeconds(-date.Second)
              .AddMilliseconds(-date.Millisecond);

static readonly Func<DateTime, DateTime> TruncateMonth =
  date => TruncateDay(date).AddDays(1 - date.Day);

static readonly Func<DateTime, DateTime> TruncateYear =
  date => TruncateMonth(date).AddMonths(1 - date.Month);

static readonly Func<DateTime, int> QuarterSwitch =
  date => Switch(date.Month % 3, 0,
            Case(1, 3),
            Case(2, 4),
            Case(0, 5));

对此:

static DateTime TruncateDay (DateTime date) 
{ 
  return date.AddHours(-date.Hour)
             .AddMinutes(-date.Minute)
             .AddSeconds(-date.Second)
             .AddMilliseconds(-date.Millisecond);
}

static DateTime TruncateMonth (DateTime date)
{ 
  return TruncateDay(date).AddDays(1 - date.Day);
}

static DateTime …

我一直在搜索,我找不到一个简单的命令行工具,它会在目录中获取一堆.java文件并编译成.class文件,然后自动将它们全部放在.jar中.我大概可以写一个脚本自己,但是这是一个领域,我在任何重新发明轮子没有兴趣(我编写了Djikstra算法一百万次,但我真的不想在这样的事情上浪费时间).

是否有一个类似于gcc或ghc的简单工具,您可以导航到目录并调用其中的文件以生成可执行的jar文件？我对gcj抱有希望,但显然可以编译为0和1.真棒,但不是我想要的.

请不要建议IDE.我不想处理netbeans,eclipse,bluej等.它们是令人惊奇的软件,但我不是在编写企业代码,而是宁愿在简单的文本编辑器中使用它.

干杯!

语境:

我在C中打开和关闭编程大约2年,然后发现它a[i]只是语法糖,*(a + i)因此相当于*(i + a)和i[a].我的现实被颠倒了,很多都是"AHA!" 在接下来的几天学习和阅读之后出现了启示时刻("那就是为什么数组总是通过引用传递!"等).从那时起,我已经内化了指针/数组的等价并将其保持在我心中,所以想象一下,当我偶然发现这个名为"数组衰变"的东西时,这是多么可怕的震撼.这是典型的例子:

码:

#include <stdio.h>

int Length(int*);

int main () {
  int arr[100];
  printf("Length of array: %d\n",(int)(sizeof(arr)/sizeof(arr[0])));
  printf("Length of array: %d\n",Length(arr));
  return 0;
}

int Length(int arr[]) {
   return sizeof(arr)/sizeof(arr[0]);
}

结果:

Length of array: 100
Length of array: 2

题:

事实证明,C毕竟对数组有一些认识!在声明数组的main中,程序能够正确地报告它的大小.现在我想知道有多少数组语法只是指针操作的语法糖(之前我曾假设:所有这些).C实际上确实有数组,它们的局限性是什么？这个例子表明只要你在同一个函数中就可以获得它们的长度,你可以做些什么呢？在这种腐烂的事情发生之前你能走多远？

我正在研究程序的一部分(关于语音识别和遥控车),其中代码transmit(XXXXX); disableAutoMode();重复多次.为了好奇,我想将其转换成一个类似的lambda函数var f = p -> transmit(p); disableAutoMode();(原谅var,我不知道这个表达式的类型是什么),然后把它在一个类似的方式:f("s");,f("a");和f("f");或类似的东西到f.call("s");,f.call("a");和f.call("f");.

在Java中使用简单的lambda函数的正确语法是什么,类似于我上面描述的？(我应该放下什么类型而不是说var？)

如果你很好奇,这是代码块:

@Override
public void onResult(Hypothesis hypothesis) {
    if (hypothesis != null) {
        String text = hypothesis.getHypstr();
        Log.i("onresult",text);
        ToastMaster(text);

        switch (text) {
            case "forward":
            case "go forward":
                transmit("f");
                disableAutoMode();
                break;
            case "go back":
            case "go backward":
            case "back":
            case "backward":
            case "reverse":
                transmit("b");
                disableAutoMode();
                break;
            case "skid left":
            case "go left":
                transmit("l"); …

我在我的公司代码库中看到了以下代码,并且自己想到"该死的linq是一个很好的路线,我想把它翻译成Haskell,看看它在实际的功能语言中是什么样的"

static Random random = new Random();
static string RandomString(int length)
{
    const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    return new string(Enumerable.Repeat(chars, length)
                                .Select(s => s[random.Next(s.Length)])
                                .ToArray());
}

然而,由于在这种语言中生成随机数有多么尴尬,我在使用简洁直接的Haskell翻译方面遇到了一些麻烦.

我考虑了几种方法.C#代码的最直接转换只生成一个随机索引,然后使用它代替random.Next(s.Length).但我需要生成多个索引,而不是单个索引.

然后我考虑做一个IO Int随机数动作列表,但我无法弄清楚如何通过并将IO动作列表转换为实际的随机数.

因此,与C#相比,我最终编写的Haskell代码看起来相当复杂(在这种情况下我没有预料到),我甚至还没有让它工作.

我的问题是,C#对Haskell的自然翻译是什么？或者更一般地说,如何在Haskell中生成指定长度的随机字符串(因为这种C#方式似乎不能很好地转换为Haskell)？

注意:我主要感兴趣的是在Haskell中生成随机字符串的算法.我对任何为我工作的标准库都不感兴趣

为什么你能这样做

int i = 10;
i.ToString();
'c'.Equals('d');
1.ToString();
true.GetType();

在C#？那些东西就是原始的,文字的,未装箱的,或者这些东西的任何组合; 那为什么他们有方法呢？它们不是对象,因此不应该有方法.这种语法糖是否适用于其他方面？如果是这样,什么？我可以理解具有执行这些操作的函数,例如:

string ToString(int number)
{
  // Do mad code
  return newString;
}

但在这种情况下,你会把它称为函数,而不是方法:

string ranch = ToString(1);

这里发生了什么？

编辑:

刚刚意识到C#不再是java克隆了,规则完全不同.哎呀:P

我正在尝试解决的现实世界问题:我有一个数据库,其中一堆电话号码以绝对可怕的格式存储为字符串(例如"(02)9971 1209").我的程序的用户将开始输入电话号码,当他输入时,他将输入的内容将被发送并用于使用"startswith"操作过滤数据库中的电话号码列表.

问题是,如果用户键入"02997",它将不会匹配任何内容,因为数字与位于括号中的位置代码一起存储.为了使此操作起作用,用户必须通过键入'(')来开始每次搜索.这不好.

tl;问题底部的博士版本

我把这个问题从它的真实世界环境中解决出来,变成了一个更小,更密集的解决方案,我可以专注于它而不会分散大量的代码库.在这种情况下,我的解决方案是做一些linq棘手:

class Program
{
    static string [] phones = {"(02) 9489 3048","(04) 1128 2148","(01) 9971 1208",};

    static void Main(string[] args)
    {
        for (;;)
        {
            Console.WriteLine("Enter your number: ");
            string input = Console.ReadLine();

            Func<string, string> strip = 
            tehstring => tehstring.Where(x => char.IsDigit(x))
                                  .Aggregate("", (x, y) => x + y);
            var results = phones.Where(z => strip(z).StartsWith(strip(input)));

            foreach (var x in results)
                Console.WriteLine(x);
        }
    }
}

这一切都很好,效果很好,完全符合我的需要.但它只适用于这个孤立的上下文:我无法将其移回需要实现的代码库,因为我需要将其转换为表达式树.

我需要解决的代码:

static Expression GetOperationExpression(
  StringFilterOperation operation, 
  Expression propertyExpression, 
  Expression valueExpression)
{
  switch …