标签: strong-typing

我想创建一个完全通用的树视图结构.这样的事情:

public class TreeView<T, K, L>
{
    public T source;
    public K parent;
    public List<L> children;
}

正如您在此类源代码中看到的那样,父代和子代都具有不同的通用数据类型.我也希望我的树视图具有无限数量的级别(不仅仅是3级).这样,当我想在代码中使用我的节点时,所有这些节点都将被强类型化.不只是我需要将它们转换为原始类型的对象.

是否有可能在c#中创建这种结构,这是一个树形视图,其所有节点都是强类型的？

谢谢

我已经完成了一些编程和Haskell,并希望在Groovy中实现一些Haskell列表处理函数.下面是一个实现unfoldr.基本上A是生成的迭代器(即列表)的类型,并且B是状态.

有两件事我想给更强的类型:

1. 我想能够说Tuple<A,B>而不仅仅是Tuple
2. 我希望能够定义闭包的参数,而不仅仅是结果类型.

其产生枚举从1至100的迭代实施例的代码是下面和上ideone链接这里.

class Unfoldr<A,B> implements java.util.Iterator<A>
{
  public Unfoldr(Closure<Tuple> f, B init) 
  {
    this.f = f;
    this.state = f(init);
  }

  public synchronized A next() 
  {
    if (hasNext())
    {
      A curr = state.get(0);
      state = f(state.get(1));
      return curr;
    }
    else
    {
      throw java.lang.NoSuchElementException;
    }
  }

  public synchronized boolean hasNext() 
  {
    return (state != null);
  }

  public void remove() { throw UnsupportedOperationException; }

  private Closure<Tuple> f;

  private Tuple …

我有一些JSON包含来自我的客户端的匿名对象.是否有一些内置机制或外部库用于将这些匿名对象转换为强类型的TypeScript对象？是否有像AutoMapper这样的东西？

我的对象是复杂类型,复杂类型作为属性.

我们来看看以下代码:

transformBi (++"asdasd") [1,2,3,4]

显然,这段代码什么都不做,但它仍然编译得很好.我想创建一个新版本的transformBi,如果编译器可以通过类型证明它是无操作,则不会编译.理想情况下,这可以通过调用的类型类来完成Contains,这样新的类型transformBi就可以了

transformBi :: (Biplate from to, Contains from to) => (to -> to) -> from -> from

我们如何实施Contains？

我正在寻找一个Contains可以自动导出的东西,而不是我必须为每个代数数据类型编写的东西.

使用普通枚举，我可以使用以下代码访问 Q_ENUMS 属性和具体的枚举的字符表示：

// in .h
class EnumClass : public QObject
{
  Q_OBJECT
public:
  enum  MyEnumType { TypeA, TypeB };
  Q_ENUMS(MyEnumType)
private:
  MyEnumType m_type;
};

// in .cpp
m_type = TypeA;
...
const QMetaObject &mo = EnumClass::staticMetaObject;
int index = mo.indexOfEnumerator("MyEnumType");
QMetaEnum metaEnum = mo.enumerator(index);
QString enumString = metaEnum.valueToKey(m_type); // contains "TypeA"

如果我想将 c++11 功能用于强类型枚举，例如

enum class MyEnumType { TypeA, TypeB };

访问元信息不再起作用。我想，Qt 不再将其识别为枚举。

是否有任何解决方案可以在使用强类型枚举时访问枚举的字符表示？

我有一个用于通过套接字连接来回传递 JSON 消息的系统。它使用标记联合来表示消息类型：

export type ErrorMessage = { kind: 'error', errorMessage: ErrorData };
export type UserJoined = { kind: 'user-joined', user: UserData };
// etc
export type Message = ErrorMessage | UserJoined | /*etc*/;

它在基本代码中运行得相当好，但我在其之上构建了一个模块，我想扩展代码。我要添加一个新的消息类型：

export type UserAction = { kind: 'user-action', action: Action }

这里的问题是我无法扩展“Message”以将我的新 UserAction 包含到联合中。我想我可以制作自己的扩展消息：

export type ExtendedMessage = Message | UserAction;

但这里的问题是，第一，这看起来很笨拙。我无法将新的 UserAction 传递到任何需要消息的方法中，即使代码实际上应该完全正常工作。以后想要扩展我的模块和基本模块的任何人都需要创建第三种类型：export type ExtendedMessageAgain = ExtendedMessage | MyNewMessage。

所以。我已经看到通过添加新的 .d.ts 文件来扩展附加属性的接口（例如 Passport 如何扩展 Express JS 的 Request 对象以添加身份验证属性），我认为标记联合也必须存在类似的东西，对吗？

但事实似乎并非如此。我用谷歌搜索了一下，没有看到这种模式在任何地方使用。这让我相信我的设计也许在某种程度上是错误的。但我没有看到解决办法。

我不想使用类，因为类型信息会通过网络被删除；该kind财产必须存在。我喜欢这个范例： …

在我看来,关于静态/强类型编程语言最有价值的是它有助于重构:如果/当你更改任何API时,编译器会告诉你这个更改已经破坏了什么.

我可以想象用运行时/弱类型语言编写代码......但是如果没有编译器的帮助我无法想象重构,我无法想象在没有重构的情况下编写成千上万行代码.

这是真的？

typedefs不强类型的原因是什么？有什么好处我看不到,还是由于向后兼容？看这个例子:

typedef int Velocity;
void foo(Velocity v) {
    //do anything;
}
int main() {
    int i=4;
    foo(i); //Should result in compile error if strongly typed.
    return 0;
}

我不是要求变通方法来获得强类型数据类型,而只是想知道为什么标准不需要typedefs强类型化？

谢谢.

我更喜欢Python的语法糖。和标准库函数。

但是我不喜欢的一个功能；是隐式键入。

是否有带有显式类型的Python发行版？哪些仍然与例如：PyPi上的软件包兼容？

[我正在研究RPython]

假设您有一个接受布尔参数的函数：

void do_something(bool use_some_option);

这有问题，因为在调用站点上，您会看到类似的内容do_something(false)，但表达能力不强。如果您有多个此类选项，情况会变得更糟，因为参数可以轻松交换。

因此，通常建议使用强类型而不是布尔值，例如enum class. 但是，您必须在某处定义该枚举，并且使用enum classin 条件语句也相当麻烦。

我的问题enum class option : bool { no, yes };是你不能使用类似的东西if(use_option){...}。

这个问题在大型代码库中经常出现，因此最好有一个默认的方法来以方便的方式处理这个问题。我当前的解决方案如下所示：

template<typename Name>
class Option {
public:
  explicit Option(bool enabled): _enabled(enabled) {}
  operator bool() { return _enabled; }
private:
  bool _enabled;
};

现在可以这样使用：

using UseMyOption = Option<struct UseMyOption_>;
void do_something(UseMyOption use_my_option) {
  if(use_my_option) {
    ...
  }
}

对于这个相当普遍的问题，这个设计有什么问题吗？隐式转换回我正在监督的 bool 是否存在任何问题，或者是否应该支持一些进一步的功能？

编辑：似乎代码可以替换为 enum UseMyOption : bool {}; 上述实现有任何行为差异吗？我还想知道为什么我以前从未见过使用该模式的建议，因为对我来说这似乎非常有用。这有什么问题吗？