小编jsd*_*sdw的帖子

在Go中,如果您定义一个新类型,例如:

type MyInt int

然后,您无法将a传递MyInt给期望int的函数,反之亦然:

func test(i MyInt) {
    //do something with i
}

func main() {
    anInt := 0
    test(anInt) //doesn't work, int is not of type MyInt
}

精细.但是为什么同样不适用于功能呢？例如:

type MyFunc func(i int)
func (m MyFunc) Run(i int) {
    m(i)
}

func run(f MyFunc, i int) {
    f.Run(i)
}

func main() {
    var newfunc func(int) //explicit declaration
    newfunc = func(i int) {
        fmt.Println(i)
    }
    run(newfunc, 10) //works just fine, even though types seem to differ
} …

这是个人练习,可以更好地理解Haskell类型系统的局限性.我想创建一个最通用的函数,它可以将一些函数应用于2个入口元组中的每个条目,例如:

applyToTuple fn (a,b) = (fn a, fn b)

我试图使这个功能在以下每种情况下都有效:

(1) applyToTuple length ([1,2,3] "hello")
(2) applyToTuple show ((2 :: Double), 'c')
(3) applyToTuple (+5) (10 :: Int, 2.3 :: Float)

因此对于length对中的项目必须是Foldable,为了显示它们必须是Show等的实例.

使用RankNTypes我可以去一些方式,例如:

{-# LANGUAGE RankNTypes #-}
applyToTupleFixed :: (forall t1. f t1 -> c) -> (f a, f b) -> (c, c)
applyToTupleFixed fn (a,b) = (fn a, fn b)

这允许可以在一般上下文中工作的函数f应用于该上下文中的项.(1)使用它,但元组项目,(2)并(3)没有上下文,所以它们不起作用(无论如何,3将返回不同的类型).我当然可以定义一个上下文来放置项目,例如:

data Sh …

我从某个模块中导出了一个函数，如下所示：

export function MyFunc<A>() {
    return {
        foo: (in: A) => void
    }
}

现在，在其他一些模块中，我希望能够讨论MyFunc. 由于我没有导出类型，我将使用typeof给定值来获取我想要的类型MyFunc。理想情况下，我会执行以下操作：

import { MyFunc } from "mymodule";
type MyFuncReturned<A> = ReturnType<typeof MyFunc<A>>;

function foo(): MyFuncReturned<string> {
   // ...
}

哼，这不行；typeof只能传递一个值并且不喜欢我尝试指定该值的泛型类型。

我能做的最好的事情就是说服 TypeScriptMyFunc从我创建的值中推断出特定类型，然后为它们提供单独的类型别名，例如：

const myFuncStringReturn = MyFunc<string>();
type MyFuncStringReturn = typeof myFuncStringReturn;

为了避免实际运行MyFunc只是为了获取类型信息，我可以将它隐藏在一个函数后面并ReturnType在它上面使用：

const myFuncStringReturn = () => MyFunc<string>();
type MyFuncStringReturn = ReturnType<typeof myFuncStringReturn>;

const myFuncBoolReturn = () => MyFunc<bool>(); …

相关:"多级继承情况下的虚拟基类"是否具有重要意义

我有一个可以继承的模板类,以便赋予一些选择功能.但是,它希望阻止任何类继承继承它的任何东西.

以下似乎实现了这一点:

template<typename Child>
class SealingClass
    {
    public:
    /*public methods etc*/
    private:
    SealingClass() {}
    friend Child;
    };

//simplify a bit:
#define Seal( x ) public virtual SealingClass< x >

现在,我可以继承上面的类,如下:

class NewClass: Seal(NewClass) {};

如果我再尝试继承NewClass,如:

class AnotherClass: public NewClass {};

然后创建所述类的实例:

AnotherClass a;

关于SealingClass私有的构造函数,我得到了所需的错误.

所以,一切都按照我的意愿行事!

但是,我注意到如果我virtual从定义中删除关键字..

#define Seal( x ) public SealingClass< x >

..我AnotherClass现在的实例工作得很好.

我理解virtual在这种情况下,关键字意味着在多重继承(例如钻石继承)的情况下只定义了基类的一个实例,其中可能存在多个实例,导致模糊的函数调用等.

但是,为什么它会影响上述功能呢？

谢谢 :)

我一直在玩Aeson和镜头包(镜头 - aeson,从核心镜头包中迁移),并且一直在努力让它们一起工作.

作为一个玩具示例,我有一个类型:

data Colour = Yellow | Green | Blue

和FromJSON实例:

instance FromJSON Colour where
    parseJSON (String s) = return $ case s of
        "blue" -> Blue
        "green" -> Green
        _ -> Yellow
    parseJSON _ = mzero

到现在为止还挺好.

现在,假设我有一些嵌套的JSON数据,我想从中提取出来:

{
    "info": {
        "colour": "yellow"
    },
    /* other props */
}

我不关心其余的,只有这种"颜色"的价值.更糟糕的是,让我们说JSON并不是特别一致,所以有时我也会这样

{ "item": { "colour": "yellow" } }

和其他时间

{ "random": {"item_colour": "yellow"} }

我希望能够尽可能轻松地获取颜色值,然后理想地使用我的FromJSON实例将其理想地解析为颜色.这是一个玩具示例,但数据类型可能包含许多字段等,而不是Color.

我开始看着镜头 - 艾森的东西,这让我有了希望; 它允许非常容易地窥视JSON结构.例:

> "{ \"info\": { \"colour\": \"yellow\" } }" ^? …

一个简单的问题.我创建了基准测试(下面的链接),至少对我来说(运行chrome 18.0.1025),每次使用array.shift()读取数组前面的值似乎比使用while/for读取值快得多循环并通过索引访问它们.

我确信这不可能是正确的,因为shift()还有很多工作要做,但与此同时我看不出我能做些什么错误来解释这个相当极端的差异？

http://jsperf.com/some-array-reading-comparisons

感谢阅读,詹姆斯

当我没有用户定义的析构函数时,编译完全正常的代码(在GCC 4.7.2上),即使提供了一个空的用户定义的析构函数,也会产生错误:

#include <memory>

class Test
{
   std::unique_ptr<int> val;
};

template <typename Type>
class B
{
public:
   //destructor:
   // if I comment this out, the code compiles just fine:
   ~B() { }

private:
   Test a;
};

int main()
{
   auto s = B<int>();
}

析构函数未注释时产生的错误中的突出点是:

• Test的复制构造函数不存在,并且没有隐式创建,因为它会形成错误
• 有人试图将唯一的复制构造函数用于unique_ptr.

对于任何感兴趣的人来说,完整的错误输出位于这篇文章的底部.

我知道unique_ptr不能复制构造(除非参数是一个rvalue),因此编译器不可能为该类生成有效的隐式复制构造函数Test.

我无法弄清楚为什么定义一个空的析构函数应该突然需要这些复制工具.显然,当unique_ptr使用s之类的东西时,这是不可能提供的.

这里的任何人都可以告诉我为什么会这样吗？

未解析析构函数时完成错误输出:

In file included from /usr/include/c++/4.7/list:64:0,
                 from ../../Dropbox/Programming/C++/test/main.cpp:2:
/usr/include/c++/4.7/bits/stl_list.h: In instantiation of 'std::_List_node<_Tp>::_List_node(_Args&& ...) [with _Args = {const Test&}; …

使用Go,我正在编写一个小实用程序,部分需要注意打开文件的文件名是否发生变化.以下代码说明了我尝试的方法:

package main

import "os"
import "fmt"
import "time"

func main() {

    path := "data.txt"
    file, _ := os.Open(path)

    for {
        details, _ := file.Stat()
        fmt.Println(details.Name())
        time.Sleep(5 * time.Second)
    }
}

这只是启动一个无限循环,运行file.Stat()以每5秒获取一次文件详细信息然后打印出名称.但是,尽管在运行时更改了文件名,但上述输出不会改变.

但是,替换details.Name()为details.Size()注意到文件大小的更改.

这只是我的Go版本中的一个错误,还是我只是做错了？我无法在任何地方找到这样的问题.

我在Mac上运行它,使用Go版本1.1.1(darwin/amd64).

在此先感谢任何回复:)

是的,所以我即将开始使用Node.js为我的网站写博客(就像任何学习过程一样),而且我一直在与自己争论使用MySQL或MongoDB中的哪一个.

搜索周围已经产生了一些"如何在Mongo中写博客"指南,但它们似乎并没有涵盖我遇到的问题.这是我的困境:

如果我要使用MySQL,我会想象我的架构是这样的:

帖子:

ID, USER, DATE, TITLE, TAGS

评论:

POST_ID, USER, DATE, MESSAGE

用户:

ID, SCREEN_NAME, IMAGE_URL

因此,每个帖子都有相关的评论,帖子和评论都有关联的用户.优点是,如果用户希望更改其屏幕名称或图像,则只需更新用户表中的一行.但是,我不确定我会如何获得包含X标签的所有帖子,除非我有多个潜在标签的多个字段？

或者,使用像MongoDB这样的东西,我正在考虑像这样格式化它:

帖子集:

{ 
    {
    _ID: something
    USER: {id: id, name: "screen name", image: "image_url"}
    DATE: ...
    TITLE: ...
    TAGS: [tag1, tag2...]
    COMMENTS: 
         [
         {USER:someone, DATE:something, MESSAGE:"hi"},
         {USER:someone, DATE:something, MESSAGE:"another message"}
         ]
    },
    {
    _ID: something,
    USER: {id: id, name: "screen name", image: "image_url"},
    DATE: ...
    TITLE: ...
    TAGS: [tag1, tag2...]
    COMMENTS: 
         [
         ...
         ]
    },
}

因此,评论嵌入在每个帖子中,这看起来很自然. …

这看起来应该很简单,但我一直在玩,并没有找到我正在寻找的解决方案,所以这里有:

我有以下结构(当然为了说明目的而简化):

template<typename T>
struct test
    {
    using L = std::list<T>;
    L::iterator a;
    };

现在,这会引发错误:

error: need 'typename' before 'test<T>::K::iterator' because 'test<T>::K' is a dependent scope

到目前为止,我发现修复它的两种方法都不太理想:

1)在使用L之前添加typename:

template<typename T>
struct test
    {
    using L = std::list<T>;
    typename L::iterator a;
    };

如果可能的话,我宁愿避免这种额外的冗长.

2)添加另一个using语句直接定位迭代器:

template<typename T>
struct test
    {
    using L = std::list<T>;
    using iter = typename L::iterator;
    iter a;
    };

但是这需要对我想要使用的每个迭代器都做同样的事情,如果我也希望访问const_iterator等等,我宁愿不必定义一堆using语句.

那么,有没有办法编写using语句,然后允许我写:

 L::iterator a;
 L::const_iterator b;
 ...

谢谢!

说我有一个像元组('a',(1,("Hello",False)).只是为了好玩(阅读:学习),我想创建一个函数,将一些正确形式的函数应用于任何这样的元组并返回结果.用法示例:

applyFnToTuple ('o',('t','w')) $ \a b c -> [a,b,c] == "otw"
applyFnToTuple ('h','i') $ \a b -> [a,b] == "hi"
applyFnToTuple ("hello",('y','o')) $ \a b c -> a ++ [b,c]

我做了大部分工作如下:

type family TupleFn ty out where
    TupleFn (a,b) output = a -> (TupleFn b output)
    TupleFn b output = b -> output

class ApplyFnToTuple a where
    applyFnToTuple :: a -> TupleFn a out -> out

instance ApplyFnToTuple b => ApplyFnToTuple (a,b) where
    applyFnToTuple (a,b) fn = applyFnToTuple …

是否可以为重载的函数签名创建类型别名？

例如，我有一个类似的功能：

function whenChanged(scope: ng.IScope, fn: ()=>void): ()=>void;
function whenChanged(fn: ()=>void, truthy:any): ()=>void;
function whenChanged(a,b): ()=>void {
    //...
}

我想为重载的签名创建类型别名以节省重复，并在我需要描述此函数类型的其他地方使用。

我试过：

type WC1 = (scope: ng.IScope, fn: ()=>void) => ()=>void;
type WC2 = (fn: ()=>void, truthy:any) => ()=>void;
type WhenChanged = WC1 | WC2;

const whenChanged: WhenChanged = (a,b) => {
    //...
};

但是尝试使用此函数时，我收到了“无法调用类型缺少调用签名的表达式”之类的错误。

我无法在文档中看到任何关于类型别名函数重载的内容。