小编luq*_*qui的帖子

我是Haskell的新手,我应该编写一个函数,在其参数中使用一个函数,使用它并返回一个函数,其行为根据我传入的函数而变化,要清楚:在我的应用程序中:一个简单的缓存服务器,我读过一个上下文文件和所有参数之间的"LOG:活动"如果日志处于活动状态我必须在屏幕上给出日志以进行调试,否则我什么都不写,我不想使用if-then链,因此我想过写一个函数

setLogging a = do
   if a
   then let logging x = putStrLn x
    in  return logging
   else let logging x = putStrLn ""
        in return logging

我以这种方式使用它doLog <- setLogging True并且它可以工作,我的函数应该返回从缓存中删除旧元素的函数:它必须包含多少元素由上下文决定; 这是我的功能

--ritorna la funzione che riduce la cache in funzione dell environment
setTrimming a = do
     if a=="active"
          then let trimming c logging = reduceCache 9  logging c --è attivo lowbandwidth
               in return trimming
          else let trimming c logging = reduceCache 5  logging c --non è attivo …

我有我想象的将是一个相当复杂的技术挑战:我希望能够以多种语言(尽可能多的)可靠地对重命名标识符进行alpha重命名.这需要特别考虑每种语言,我正在寻求建议,以便通过共享代码来最大限度地减少我需要做的工作量.像已经支持多种语言的统一解析或抽象语法框架这样的东西会很棒.

例如,这是一些python代码:

def foo(x):
    def bar(y):
        return x+y
    return bar

的α重命名x以y 改变x到y和保持语义.所以它会成为:

def foo(y):
    def bar(y1):
        return y+y1
    return bar

了解我们如何重命名y以y1避免破坏代码？这就是为什么这是一个难题.似乎程序必须非常了解构成范围的内容,而不仅仅是进行字符串搜索和替换.

我还想尽可能多地保留格式:注释,间距,缩进.但这不是100%必要的,它会很好.

有小费吗？

我正在阅读有趣的幽灵类型.第一个练习询问为什么有必要为在幻影类型上运行的函数提供签名.虽然我无法提出一般原因,但我确实在以下示例中看到了一个问题:

data Expr a where
  I :: Int -> Expr Int
  B :: Bool -> Expr Bool
  Add :: Expr Int -> Expr Int -> Expr Int
  Eq :: (Eq a) => Expr a -> Expr a -> Expr Bool


whatIs (I _) = "an integer expression"
whatIs (Add _ _) = "an adition operation"

现在我明白whatIs上面有两种可能的类型,即:

Expr a -> String

和

Expr Int -> String

但是,编译器会给出错误:

• Couldn't match expected type ‘t’ with actual type ‘[Char]’ …

我必须在haskell中编写一个函数来检查两个二进制树是否是彼此的镜像.这是我到目前为止,但我不知道True && isMirrorImages l1 r2 && areMirrorImages r1 l2是否是正确的方法.我试图用递归调用areMirrorImages函数的结果来逻辑AND True.

-- Tests whether two BinaryTrees are mirror images of one another
areMirrorImages :: (Eq (BinaryTree a), Eq a) => BinaryTree a -> BinaryTree a -> Bool
areMirrorImages Empty Empty = True
areMirrorImages _ Empty = False
areMirrorImages Empty _     = False
areMirrorImages (Node x1 left1 right1) (Node x2 left2 right2) = 
    if (x1 == x2 && left1 == right2 && right1 == left2)
then True && (areMirrorImages left1 right2) && …

我有以下问题:

定义功能

and, or :: [Bool] -> Bool

Run Code Online (Sandbox Code Playgroud)

它给出了一个布尔列表的连接和分离.例如,

and [False, True] = False
or  [False, True] = True

Run Code Online (Sandbox Code Playgroud)

在空列表中and给出True并or给出False; 解释这些选择的原因.

我知道我可以回答它,但我不确定最有效的方法来解决它.任何帮助将非常感激.

我的解决方案是这样的(但我认为它可能更有效):

and, or :: [Bool] -> Bool

and []             = True
and [True, True]   = True
and [False, False] = True
and [True, False]  = False

or []             = False
or [True, True]   = False
or [False, False] = False
or [True, False]  = True

我正在编写一个函数,它从列表中获取元素并返回它们.

我觉得很简单.但是当使用"take"时,例如:take 2 [1.2,3,4]

它返回:[1.2,3.0]当我真正想要的时候[1.2, 3]

我想创建一个遍历列表并减少不必要的小数的函数,但我无法理解它看到haskell不接受我与x&round(x)的比较

function :: [a] -> [a]
function(x:xs)
 if x == round(x) = round(x):function xs
 else x:function xs

那么答:有没有更简单的解决方案？B:为什么不能将x与圆(x)进行比较？

有人可以向我解释,为什么下面的代码是memoization:

fib_mem :: Int -> Integer
fib_mem = (map fib [0..] !!)
where fib 0 = 1
      fib 1 = 1
      fib n = fib_mem (n-2) + fib_mem (n-1) 

我有以下数据类型。

data NestedList a = Elem a | List [NestedList a]

不幸的是，创建这种数据类型的样本非常麻烦。

List [Elem 5, Elem 6, Elem 7, List [Elem 8, Elem 9, Elem 10]]

我想创建一个fromList将使用任何类型的平面数组的辅助程序，并返回一个NestedList，该NestedList也是平面的但包含相同的数据。因此，我可以通过以下方式使用帮助程序制作上面的示例（不包括开始嵌套的部分）：

fromList [5, 6, 7] == List [Elem 5, Elem 6, Elem 7]

到目前为止，这就是我所拥有的。

fromList :: [a] -> NestedList a
fromList [] = List[]
fromList [a] = Elem a
fromList (x:xs) = List [Elem x] ++ List [fromList xs]

错误消息是：

• Couldn't match expected type ‘[a0]’ with actual type ‘NestedList a’
• …

我有这样的情况。

struct ViewModel {...};
struct Movable : virtual ViewModel {...};
struct Selectable : virtual ViewModel {...};

（这些都是没有数据成员的“接口”类）

有许多类似于Movable和 的子接口Selectable，描述了ViewModel可能有也可能没有的不同功能，以及使用这些功能的相应方法。这个想法是 aViewModel将实现一堆这些。

现在我正在实现一个功能，它需要一个ViewModel既是Movable又是Selectable. 我当然可以

struct MoveSelectable : virtual Movable, virtual Selectable {};

并要求MoveSelectable实施，但这太多了。是否有可能制作一个组合器，这样我就可以在不必引入新类的情况下做到这一点，这样视图模型实现者就不需要知道这种组合？例如，

void selectAndMove(intersection<Movable, Selectable>* viewModel) {...}

你好为什么我使用递归的反向方法不起作用？print语句显示操作正确完成,但最后看起来只有整个String的非常多的char被赋值给h.

    public static String reverse(String s,String h){

    if(s.length()==0){

        return s;

    } else {


        h+=s.charAt(s.length()-1);
        System.out.println(h);//FOR TEST
        s=s.substring(0,s.length()-1);
        reverse(s,h);
        return h;
    }

}

有什么建议？