小编Ear*_*ine的帖子

我想在Haskell中实现阴阳拼图.这是我的尝试(不成功):

-- The data type in use is recursive, so we must have a newtype defined
newtype Cl m = Cl { goOn :: MonadCont m => Cl m -> m (Cl m) }

yinyang :: (MonadIO m, MonadCont m) => m (Cl m)
yinyang = do
    yin <-  (callCC $ \k -> return (Cl k)) >>= (\c -> liftIO (putStr "@") >> goOn c)
    yang <- (callCC $ \k -> return (Cl k)) >>= (\c -> liftIO …

我正在尝试将我的应用添加到共享表.如果你看一张照片并按下分享按钮,你会看到Facebook twitter ...

最近我从商店下载了一些应用程序,它们也出现在共享表中,所以我认为它可能在某种程度上.

可能吗？如果是这样的话

这个问题不是什么

1. 这不仅仅是在您创建的应用之间共享数据.通常,自定义URL方案是出于此目的,但仅当您的数据源知道如何使用自定义方案时.但是这个问题是关于如何让你的应用程序为第三方应用程序(即照片)做好准备,以便与你分享标准内容(照片,电影等).

2. 这不是关于如何准备您的内容以分享在Facebook或Twitter上.相反,它询问如何编写自己类似Facebook的应用程序,以便它可以接受共享

我注意到在Java中Array.newInstance()返回Object,而不是T[].这是可以理解的,因为在Java支持泛型类型之前引入了此方法.

然而,令人惊讶的是,没有相同的通用版本.Java 7 Arrays.copyOf是不一样的 - 它复制参数的内容,而不是创建一个新的虚拟数组(里面有所有空对象).

由于实现这一点似乎微不足道,有没有理由不将它添加到JRE中？或者我找不到一个？

UPDATE

我似乎会提供自己的"琐碎"实施来阻止对这个问题的误解.

class MyArrayUtil {
    //Generic version for classes
    @SuppressWarnings("unchecked")
    public static <T> T[] newArrayOf(T[] t, int len){
        return (T[]) Array.newInstance(t.getClass().getComponentType(), len);
    }
    //For array of int
    public static int[] newArrayOf(int[] t, int len){
        return new int[len];
    }
    //For other primitive types...
}

我不会将此代码作为答案发布,因为它不是问题的答案.问题是出于原因和/或现有代码,而不是如何实施.

UPDATE

我已经更新了代码以使其类似Arrays.copyOf,并且优点是程序员可以简单地更改参数的类型以调整其他类型的代码.我也删除了Array.newInstance原始类型的使用.

我想定义一个具有以下属性的函数

symmetricLazyOr :: Bool -> Bool -> Bool
symmetricLazyOr True _|_ === True
symmetricLazyOr _|_ True === True

否则它就像正常一样工作or.

在Haskell中甚至可能吗？

UPDATE

这个问题主要关注语义而不是实现细节.直观地,or应该是对称的,这意味着or a b === or b a所有给定的a和b.然而,这是不是真的在Haskell,因为or _|_ True === _|_同时or True _|_ === True.

要求是将附件上载到服务器.但是,我们只想上传那些出现在Outlook的"消息"行(见下图)中的内容,电子邮件正文中没有其他内容.

由于Outlook本身知道应该在行中显示哪个附件,因此必须有用于在内部区分它们的信息.

那么,我怎样才能在我的VBA计划中做到这一点？我试过使用,MailItem.Attachments但所有附件都在那里,我找不到它们的任何属性可以用来区分.

更新 原始标题"用Outlook VBA区分附加附件"有点误导.所以我改变了标题.

Outlook截图:

在J. Barkley Rosser的" 数学家的逻辑 "中,他用一种符号来避免括起来太多.虽然我不知道逻辑学家什么时候开始使用这种符号,但我知道这本书于1957年首次出版,而JGP Nicod在1916年出版的论文也使用了这种符号.显然它有着悠久的历史,尽管现在这并不受现代逻辑学家的青睐.

在编程世界中,在LISP类似的编程语言中,程序员要跟踪正确(大量)括号的数量是一个巨大的挑战.Haskell提供了一个$提供部分功能的操作符,但是因为你不能说它2 * $ 3 + 4不像点那样强大(见下面的例子).C语言序列使用传统的操作优先级,但在某些情况下仍然需要深嵌套括号.所以我想知道为什么没有实际语言使用这种策略？我试过了,但我发现甚至都不能为它写一个语法!

让我给一个玩具计算机语言的一些例子,只有两个运营商+,并*和所有条款都是整数.

使用此表示法,翻译者应通过以下测试用例:

1 + 3 .* 2
= (1 + 3) * 2
1 *. 3 + 2
= 1 * (3 + 2)
1 *. 2 +. 2
= (1 * 2) + 2
2 *: 2 + 3 .* 4
= 2 * ((2 + 3) * 4)

我无法解释这种符号的所有细节,它在Rosser的书中花费了近5页.但是在genaral(和short)中,.操作符之前或之后的一个点代表一个"分隔符",将两边推开.冒号: …

在C++中,为了定义一个只能在同一个文件中访问的符号,我们说

namespace 
{
    class my_private_class
    { ... }
}

但我可以在C#中做同样的事情吗？或者我必须说

namespace __DO_NOT_USE_OUT_OF_.xxx.cs__ 
{       
  public MyPrivateClass 
  { ... }
}

using __DO_NOT_USE_OUT_OF_.xxx.cs__;

(假设这是在一个名为xxx.cs的文件中)？原因的后者将取决于其他程序员是否尊重.

我问了一个相关的问题,为什么没有执行From<&String>for String.我现在想要创建自己的特征,如下所示:

#[derive(Debug)]
struct MyStruct(String);

impl MyStruct {
    fn new<T>(t: T) -> MyStruct
    where
        T: MyIntoString,
    {
        MyStruct(t.my_into())
    }
}

trait MyIntoString {
    fn my_into(self) -> String;
}

impl<'a> MyIntoString for &'a String {
    fn my_into(self) -> String {
        self.clone()
    }
}

impl<I> MyIntoString for I
where
    I: Into<String>,
{
    fn my_into(self) -> String {
        self.into()
    }
}

fn main() {
    let s: String = "Hello world!".into();
    let st: MyStruct = MyStruct::new(&s);
    println!("{:?}", st);
} …

从 Rust 1.34 开始，我们可以通过实现TryFromtrait来编写类型之间的易错转换：

struct Foo(i32);
struct Bar;

impl TryFrom<Bar> for Foo {
    type Error = ();
    fn try_from(_b: Bar) -> Result<Foo, ()> {
        Ok(Foo(42))
    }
}

在 Rust 1.41 中，孤儿规则已经放宽，所以我们也可以这样写：

struct Foo(i32);
struct Bar;

impl From<Bar> for Result<Foo, ()> {
    fn from(_b: Bar) -> Result<Foo, ()> {
        Ok(Foo(42))
    }
}

根据这个试验，这两种解决方案似乎同样有效。

采用一种或两种方法的优缺点是什么？两者如何选择？

这个问题对生态系统很重要。例如，一个 crate 编写者需要关于是否支持TryFrom，From或两者都支持的建议。宏编写者需要知道它是否需要同时处理这两种情况等。这取决于当今生态系统的状态，不能轻易回答。

我刚刚发明了以下替代定义Maybe:

type Maybe' a = forall b. (b -> (a -> b) -> b)

just :: a -> Maybe' a
just a = \d f -> f a

nothing :: Maybe' a
nothing = const

bind :: Maybe' a -> (a -> Maybe' b) -> Maybe' b
bind ma f = ma nothing (\a -> f a)

问题是我无法添加以下实例声明

instance Monad (Maybe') where
    return = just
    a >>= f = bind a f

错误消息是:

Type synonym Maybe' should have …