小编Dar*_*rio的帖子

是否可以在C#中实施McCarthy的amb-operator用于非确定性选择？

显然.NET缺乏持续支持但yield return可能有用.这可能在其他静态.NET语言中如F#吗？

偶尔我发现我需要通过在每个项目之后插入一个新项目来处理列表,除了最后一个项目.类似于在字符串列表的每个项目之间放置逗号的方式.

我厌倦了每次编写最后一个(或第一个)项目的特殊情况,所以我在Linq风格的扩展中捕获了模式:

public static IEnumerable<T> Separate<T>(this IEnumerable<T> source, 
                                         Func<T> separator)
{
    bool first = true;
    foreach (T item in source)
    {
        if (first)
            first = false;
        else
            yield return separator();

        yield return item;
    }
}

例如,这允许我以编程方式使用超链接以编程方式填充流文档,但每个文件之间有换行符:

para.Inlines.AddRange(_recentFiles.Select(f => f.ToHyperlink())
                                  .Separate(() => new LineBreak()));

假设System.Linq.Enumerable中不存在这个(这是我在写这样的东西之后通常会立即发现的),问题是,Separate在其他功能框架或语言中通常调用的列表上的这个操作是什么？

是否有任何类型安全的,编译时检查的可能性来引用实现多个接口的值？

特定

interface A {
    void DoA();
}

interface B {
    void DoB();
}

我可以编写代码实现对象A 或 B,但不能同时使用.所以我想出了丑陋的包装:

class ABCollection {
    private class ABWrapper : A, B {
        private readonly A a;
        private readonly B b;

        public static ABWrapper Create<T>(T x) where T : A, B {
            return new ABWrapper { a = x, b = x };
        }

        public void DoA() {
            a.DoA();
        }

        public void DoB() {
            b.DoB();
        }
    }

    private List<ABWrapper> data = new List<ABWrapper>();

    public …

我正在尝试在 WPF 中编写一个小照片查看器，基本上模拟Windows 照片查看器提供的功能。

以窗口和全屏模式显示是使用Image

<Image Name="ImgDisplay" Source="{Binding CurrentImage.FullPath, Converter={StaticResource FilenameToImageConverter}}"/>

其中FilenameToImageConverter执行以下操作

public class FilenameToImageConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            string uri = value as string;

            if (uri != null && File.Exists(uri))
            {
                BitmapImage image = new BitmapImage();
                image.BeginInit();
                image.CacheOption = BitmapCacheOption.None;
                image.UriCachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.BypassCache);
                image.CacheOption = BitmapCacheOption.OnLoad;
                image.CreateOptions = BitmapCreateOptions.IgnoreImageCache;
                image.UriSource = new Uri(uri);
                image.EndInit();
                return image;
            }

            return null;
        }

        public object ConvertBack(object …

这里我们有一个函数定义:

let f x = x + 3;;

这是一个表达式:

let g = 4;;

可以g被认为是不带参数的常量函数吗？有什么区别吗？

在Haskell中使用monadic表达式时,使用liftM's(甚至在中缀位置)对我来说通常看起来非常不美观和冗长.

大多数其他monadic原语(>>=,>>)甚至liftM是纯粹的链接 $都是中缀运算符.这让我想到为什么monadic提升没有操作符号.

对于操作符号(或者为什么不应该有符号),您是否有合理,一致的建议？(我想的>-和-<(通过函数移位单子),但它们似乎在箭头的上下文不同的含义.)

我的问题:

我有一个MySQL数据库,按时间顺序存储大量的气象数据(每10分钟插入一次新数据).不幸的是,有几次停电,因此缺少某些行.我最近设法从气象站获取了某些备份文件,现在我想使用它们填写缺失的数据.

DB就是这样的结构(例子):

date*            the data    
2/10/2009 10:00  ...
2/10/2009 10:10  ...
( Missing data!)
2/10/2009 10:40  ...
2/10/2009 10:50  ...
2/10/2009 11:00  ...
...

*= datatime-type,主键

我的想法:

由于备份和数据库位于不同的计算机上并且流量非常慢,我想到了创建一个MySQL查询,该查询在运行时将返回指定时间范围内所有缺失日期的列表.然后,我可以从备份中提取这些日期并将它们插入到数据库中.

问题:

怎么写这样的查询？我没有权限创建任何辅助表.是否可以在指定的时间间隔内制定所有必需日期的"虚拟表",然后在JOIN？中使用它？或者是否有完全不同的命题来解决我的问题？

编辑:是的,时间戳始终采用上面显示的格式(总是10分钟),除了一些只是缺失.

好的,临时表怎么样？是否有一种优雅的方式自动填充时间范围？如果两个脚本试图同时运行,这会导致表格出现问题吗？

我一直在F#中编写一个小的monadic解析器 - 组合器库(有点类似于FParsec),现在尝试为编程语言实现一个小的解析器.

我首先在Haskell(使用Parsec)中实现了代码,该代码运行得非常好.中缀表达式的解析器是相互递归设计的.

parseInfixOp :: Parser String -> Parser Expression -> Parser Expression
parseInfixOp operatorParser subParser = ignoreSpaces $ do
                                          x <- ignoreSpaces $ subParser
                                          do
                                            op <- ignoreSpaces $ operatorParser
                                            y  <- parseInfixOp operatorParser subParser
                                            return $ BinaryOp op x y
                                           <|> return x

parseInfix :: [String] -> Parser Expression -> Parser Expression
parseInfix list = parseInfixOp (foldl1 (<|>) $ map string list)

parseExpr :: Parser Expression
parseExpr = parseInfix0

parseInfix0 = parseInfix ["==", "<>", "And", …

我有一个分层嵌套的关联数组.它看起来像这样:

A = { 
    B = { 
        C = {}, 
        D = {}, 
    }, 
    E = { 
        F = { 
            G = {} 
        } 
    }, 
    H = {} 
}

我想编写一个函数来返回每个键的"祖先".

所以:

f("A") = {"A"} 
f("B") = {"B","A"} 
f("C") = {"C","B","A"} 
f("G") = {"G","F","E","A"} 
f("fake") = {} 

我已经解决了我需要使用递归,但是我在编写函数时遇到了困难.有人能给我一些关于如何编写这样一个函数的指示吗？

(请不要转介我http://xkcd.com/138/!)

我仍然是Scala noob,这让我很困惑:

import java.util.regex._

object NumberMatcher {
  def apply(x:String):Boolean = {
    val pat = Pattern.compile("\\d+")
    val matcher = pat.matcher(x)
    return matcher.find
  }

  def unapply(x:String):Option[String] = {
    val pat = Pattern.compile("\\d+")
    val matcher = pat.matcher(x)
    if(matcher.find) {
      return Some(matcher.group())
    }
    None
  }
}

object x {
  def main(args : Array[String]) : Unit = {
    val strings = List("geo12","neo493","leo")
    for(val string <- strings) {
      string match {
        case NumberMatcher(group) => println(group)
        case _ => println ("no")
      }
    }
  }
}

我想为包含数字的字符串添加模式匹配(所以我可以了解更多关于模式匹配的内容),并且unapply …