标签: generic-programming

我必须经常在Scala中转换"矩形"集合集合,例如:地图列表,列表地图,地图地图,一组列表,集合地图等.因为集合可以统一被视为从特定域到共域的映射(例如:List [A]/Array [A]是从Int域到A域的映射,Set [A]是来自A的映射域到布尔共域等),我想编写一个干净的通用函数来进行转置操作(例如:将列表映射转换为转置的映射列表).但是,我遇到了麻烦,因为除了()运算符之外,Scala似乎没有统一的API来抽象地查看集合作为映射？

所以我最终为每种类型的集合集合编写了一个单独的转置,如下所示:

def transposeMapOfLists[A,B]( mapOfLists: Map[A,List[B]] ) : List[Map[A,B]] = {
  val k = ( mapOfLists keys ) toList
  val l = ( k map { mapOfLists(_) } ) transpose;
  l map {  v => ( k zip v ) toMap }
}

def transposeListOfMaps[A,B]( listOfMaps: List[Map[A,B]]) : Map[A,List[B]] = {
  val k = ( listOfMaps(0) keys ) toList
  val l = ( listOfMaps map { m => k map { m(_) } } ) transpose;
  ( …

我在下面的方法中写了以下要求 -

1. 输入是xmlnode和attributeName
2. 如果找到并传递了关联的属性名称,则返回该值

3. 如果传递的attributeName中没有值,则应返回 -

   3.1.对于int -1 3.2.对于Datetime DateTime.MinValue 3.3.对于String,null 3.4.对于bool,null

情况3.4下面的方法失败.

public T AttributeValue<T>(XmlNode node, string attributeName)  
        {
            var value = new object();

            if (node.Attributes[attributeName] != null && !string.IsNullOrEmpty(node.Attributes[attributeName].Value))
            {
                value = node.Attributes[attributeName].Value;
            }
            else
            {

                if (typeof(T) == typeof(int))
                    value = -1;
                else if (typeof(T) == typeof(DateTime))
                    value = DateTime.MinValue;
                else if (typeof(T) == typeof(string))
                    value = null;
                else if (typeof(T) == typeof(bool))
                    value = null;



            }
            return (T)Convert.ChangeType(value, typeof(T));
        }

当改变这个

public System.Nullable<T> AttributeValue<T>(XmlNode node, string …

我最近添加了一个alterF函数Data.Map,这是一个翻转形式Control.Lens.At.at.

alterF :: (Ord k, Functor f)
       => (Maybe a -> f (Maybe a))
       -> k
       -> Map k a
       -> f (Map k a)

alterF被设计为能够提供合理的性能,即使对于非常"沉重"的仿函数[],甚至当密钥相当昂贵时也是如此.不幸的是,它比一个轻量级算子和便宜比较键的更常见情况下的速度慢一些.

为了解决这个问题,我为这些Const b和Identity仿函数添加了GHC重写规则,将它们重写为通常更快的更简单的实现.我准备添加另一个,因为(,) b.我添加了一个(,) b然后将其删除.请参阅下面的更新.

但是,我对我需要一个特定规则的事实感到有些恼火(,) b,因为还有许多其他仿函数遵循相同的模式.特别是,任何时候定义仿函数

data F b1 b2 ... a = F e1 ... a ... e_n

在没有e_k提及的地方a,我应该能够以同样的方式重写它.有没有办法用GHC做到这一点RULES？或者我将不得不等待更一般的重写系统？

更新

可悲的是,我意识到我对对的重写规则是无效的(它太严格了),并且修复使得它不那么明显有益.所以我现在已经取消了这条规则.不过,我认为一般性问题仍然很有意思.

有没有办法创建一个处理项目列表的数据模板？

我有Contact.Phones(EntityCollection<Phone>),我希望数据模板处理列表 - 添加删除编辑等.

有没有办法将DataTemplate的DataType属性设置为泛型EntityCollection<Phone>？

我是Haskell的新手(仍在努力完全理解monads).我有一个问题,我有一个树状的结构

type Tree = [DataA]

data DataA =  DataA1 [DataB] 
            | DataA2 String 
            | DataA3 String [DataA]
               deriving Show

data DataB =  DataB1 [DataA] 
            | DataB2 String 
            | DataB3 String [DataB]
               deriving Show

我想要做的是能够遍历这个并生成一个带过滤器的新树.例如,我可能想要将树中的所有DataB2更改为"foo".

我已经看到了树在同一数据部分中的示例,并且构造函数是相似的.

在python世界中,我只是遍历列表,匹配我需要的任何东西,并替换值.

在Haskell中我猜我需要能够复制我的树,但是你如何处理隐藏在构造函数和不同数据类型中的列表？

我知道这不是一个很好的问题,我可能会被诅咒问它,但我找不到任何地方可以帮助解决这个问题

下面是我的面试问题中出现的通用课程(我已经失败了).问题是告诉这个类声明正在做什么以及在什么情况下可以使用它？

我对通用编程的理解非常有限,但我理解'T'是Type,'extends'在这里意味着Type应该继承'SimpleGenericClass',但我不理解'？' 最后以及在什么情况下这个类可能被用于

public abstract class SimpleGenericClass<T extends SimpleGenericClass<?>> {

}

我正在用纯C编写通用链表实现.

struct Node {
    void *value;
    struct Node *next;
};

struct LinkedList {
    struct Node *start;
    struct Node *end;
};

void LinkedList_new(struct LinkedList* llist) {
    llist->start = 0;
    llist->end = 0;
    return;
}

void addNode( struct LinkedList *ll, void *_value ) {
    if ( NULL == ll->start ) {
        ll->start = (struct Node *) malloc( sizeof(struct Node) );
        ll->end = ll->start;
    } else {
        ll->end->next = (struct Node *) malloc( sizeof(struct Node) );
        ll->end = ll->end->next;
    }
    ll->end->value = _value; …

我有一个类型类Cyclic,我希望能够提供泛型实例.

class Cyclic g where
    gen :: g
    rot :: g -> g
    ord :: g -> Int

给定一个类型的nullary构造函数,

data T3 = A | B | C deriving (Generic, Show)

我想生成一个等效于此的实例:

instance Cyclic T3 where
    gen   = A
    rot A = B
    rot B = C
    rot C = A
    ord _ = 3

我试图找出所需的Generic机器

{-# LANGUAGE DefaultSignatures, FlexibleContexts, ScopedTypeVariables, TypeOperators #-}

import GHC.Generics

class GCyclic f where
    ggen :: f a
    grot :: f a …

给定此数据类型

data Val = X Int | Y Bool | Z Double deriving (Eq, Show)

以及诸如的列表

let vals = [X 1, Z 2.7, Y True, X 2, Z 3.14, Y True]

如何将元素分组vals到此列表中,

[[X 1,X 2],[Y True,Y True],[Z 2.7, Z 3.14]]

Boost Hana提供了以简单而美观的方式对类成员字段进行内省的能力:

// define:

struct Person {
  std::string name;
  int age;
};

// below could be done inline, but I prefer not polluting the 
// declaration of the struct
BOOST_HANA_ADAPT_STRUCT(not_my_namespace::Person, name, age);

// then:

Person john{"John", 30};
hana::for_each(john, [](auto pair) {
  std::cout << hana::to<char const*>(hana::first(pair)) << ": "
            << hana::second(pair) << std::endl;
});

但是,文档仅提及成员字段.我也想对方法进行反思.我试图用一种方法天真地扩展示例:

struct Foo {
    std::string get_name() const { return "louis"; }
};

BOOST_HANA_ADAPT_STRUCT(::Foo, get_name);

这编译.但是,只要我尝试使用它,使用类似于上面的代码(for_each...),我就会遇到很多编译错误.由于没有显示方法内省的例子,我想知道它是否得到支持.