标签: pattern-guards

在我正在阅读的代码库中,我发现了一个像这样的函数声明(缺少某些部分):

filepathNormalise :: BS.ByteString -> BS.ByteString
filepathNormalise xs
    | isWindows, Just (a,xs) <- BS.uncons xs, sep a, Just (b,_) <- BS.uncons xs, sep b
    = '/' `BS.cons` f xs

逗号在这里做什么？

(只有作为奖励,如果有人知道这一点:Haskell编程中提到的这个语法是从第一原则开始的,如果是这样的话,在哪里？我记不起来了解它.)

当使用模式匹配模式匹配并打开所有警告时,我正在观察一个有趣的行为

{-# OPTIONS_GHC -Wall #-}
module Mood where

data Mood = Happy
          | Indifferent
          | Sad
          deriving Show

flipMood :: Mood -> Mood
flipMood Happy       = Sad
flipMood Indifferent = Indifferent
flipMood Sad         = Happy

flipMood' :: Mood -> Mood
flipMood' mood
  | Happy       <- mood = Sad
  | Indifferent <- mood = Indifferent
  | Sad         <- mood = Happy

即使flipMood并且flipMood'几乎做同样的事情我得到以下错误消息:

Mood.hs:15:1: Warning:
    Pattern match(es) are non-exhaustive
    In an equation for ‘flipMood'’: Patterns not matched: _ …

我正在通过了解你是一本哈斯克书,在第8章中有一段代码看起来像这样

data LockerState = Taken | Free deriving (Eq, Show)
type Code = String
type LockerMap = Map.Map Int (LockerState, Code)

lookup' :: Int -> LockerMap -> Either String Code
lookup' num_ map_ =
   case (Map.lookup num_ map_) of
      Nothing -> Left $ "LockerNumber doesn't exist!"
      Just (state, code) -> if state == Taken
                              then Left $ "LockerNumber already taken!"
                              else Right $ code

这有效.但是,我想将if/else块转换为保护语句,如下所示:

lookup' :: Int -> LockerMap -> Either String Code
lookup' num_ map_ = …

我正在编写一个关于音程分类的程序.概念结构非常复杂,我会尽可能清楚地表达它.前几行代码是一个正常工作的小提取.第二个是伪代码,可以满足我的简洁需求.

interval pt1 pt2
  | gd == 0 && sd <  (-2) = ("unison",show (abs sd) ++ "d") 
  | gd == 0 && sd == (-2) = ("unison","dd")
  | gd == 0 && sd == (-1) = ("unison","d")
  | gd == 0 && sd == 0    = ("unison","P")
  | gd == 0 && sd == 1    = ("unison","A")
  | gd == 0 && sd == 2    = ("unison","AA")
  | gd == 0 && sd >  2    = ("unison",show sd ++ …

我的Haskell项目包括一个表达式求值程序,为了这个问题的目的可以简化为:

data Expression a where
    I :: Int -> Expression Int
    B :: Bool -> Expression Bool
    Add :: Expression Int  -> Expression Int  -> Expression Int
    Mul :: Expression Int  -> Expression Int  -> Expression Int
    Eq  :: Expression Int  -> Expression Int  -> Expression Bool
    And :: Expression Bool -> Expression Bool -> Expression Bool
    Or  :: Expression Bool -> Expression Bool -> Expression Bool
    If  :: Expression Bool -> Expression a    -> Expression a -> Expression a …

我最近遇到了以下代码，这让我很困扰

lowerSafeForeignCall dflags block
| (entry, middle, CmmForeignCall { .. }) <- blockSplit block
= do
 -- do block stuffs
 -- Block doesn't end in a safe foreign call:
| otherwise = return block

这段代码来自 https://phabricator.haskell.org/rGHCb0534f78a73f972e279eed4447a5687bd6a8308e

在文件editor / cmm / CmmLayoutStack.hs中

983行

我真的很想知道第二行是什么<-。我相信lowerSafeForeignCall是一个函数，并且| “ 否则 ”表示此功能使用了防护功能。所以

(entry, middle, CmmForeignCall { .. }) <- blockSplit block

必须是布尔类型。但是<-在任何do块之外。我在网上做了一些搜索，但仍然没有关于此用法的任何线索。

根据这些定义,学习Haskell并且我不确定为什么我没有得到预期的结果:

instance Ring Integer where
  addId  = 0
  addInv = negate
  mulId  = 1

  add = (+)
  mul = (*)

class Ring a where
  addId  :: a            -- additive identity
  addInv :: a -> a       -- additive inverse
  mulId  :: a            -- multiplicative identity

  add :: a -> a -> a     -- addition
  mul :: a -> a -> a     -- multiplication

我写了这个函数

squashMul :: (Ring a) => RingExpr a -> RingExpr a -> RingExpr a
squashMul x y
  | …

我想知道是否有更好的解决方案(或者如果我的解决方案是正确的),创建if变量和守卫的行为.

目标:

• 如果变量设置为true,则编译代码(工作)
• 如果将变量设置为其他任何内容,请忽略该代码(默认,有效)
• 保持初始代码位置(dosnt工作,在任何地方.responsive (@responsive);被合并)

我的代码:

@responsive: true;

.responsive(true){
  a {
    color: red;
  }
}

.responsive(true) {
  b {
    color: blue;
  }
}

.responsive (@responsive);

stackoverflow-frs,

我正在学习Erlang.有人能指出我为什么要得到illegal guard expression这个警卫？

add_new_prime(Idx, Primes, Ref) when length(Primes) =:= 0 ; math:sqrt(Idx) < hd(Primes) -> Ref ++ [Idx];

如果我只是做"取消优化"它 add_new_prime(Idx, Primes, Ref) when length(Primes) =:= 0 -> Ref ++ [Idx];

有用.我已经看到了多个例子,其中每个子句有多个"语句",但不明白为什么我的工作不起作用.

非常感谢!

我在code.google.com上阅读了关于模式保护的内容,其中显示了这种类型的警卫:

match x with
| pat with g = y -> z
| ...
| pat with g = y -> z

然而,在OCaml 4.02中,似乎没有工作(Syntax error: pattern expected.),所以问题是:在模式匹配中有一种解决方法可以实现这种绑定吗？我想写那样的东西

match something with
| value with y = f x when y > 0 -> value + y

在此先感谢,欢呼.