标签: pattern-matching

在许多情况下,我发现自己需要在结构本身及其字段上进行模式匹配,并在某些中间结果不为空时继续执行一些进一步的操作.

但是,结构本身可能是nil第一位的.这导致我编写了多个嵌套匹配,例如

experiment = Repo.get(Experiment, experiment_id)

case experiment do
  nil ->
    # Error 1

  _ ->
    case experiment.active do
      false -> # Error 2
      true -> 
        case Repo.all(assoc(experiment, :experiment_results)) do
          [] -> # Error 3
          results -> # Do stuffs
    end
end

理想情况下,我想编写没有那么多嵌套的代码.

我该如何重构代码？

(请注意,我原来的问题是关于结构上的模式匹配nil.我的实际用例比我原来提出的问题更广泛,因此我更新了问题.)

原始代码,AlekseiMatiushkin和Sheharyar的答案适用于:

experiment = Repo.get(Experiment, experiment_id)

case experiment do
  nil ->
    :error

  _ ->
    case experiment.active do
      false -> :error
      true -> # Do stuffs
    end
end

我在关于actix的文档中找到了以下代码:

#[macro_use]
extern crate failure;
use actix_web::{error, http, HttpResponse};

#[derive(Fail, Debug)]
enum UserError {
    #[fail(display = "Validation error on field: {}", field)]
    ValidationError { field: String },
}

impl error::ResponseError for UserError {
    fn error_response(&self) -> HttpResponse {
        match *self {
            UserError::ValidationError { .. } =>
                HttpResponse::new(http::StatusCode::BAD_REQUEST),
        }
    }
}

{ .. }这里的意思是什么？

我需要在Haskell中编写一个函数,给定一个至少包含7个元素的列表,返回一个包含第一个和第七个元素的元组.

例如

Prelude> take1and7 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
(1, 7)

我试过这个

take1and7 :: [a] -> (a, a)
take1and7 [a, b, c, d, e, f, g, xs] = (a, g)

但它说它有"非详尽的模式",我不明白

我有一个Map[String, Boolean]与各种度量数据和一个单独的Seq[String]包含metricKeys.

问题是Map可能不包含所有,metricKeys但我需要保留有关不存在的值的信息.我试过通过使用来解决这个问题.getOrElse.我预计List[String]带有度量值的结果将包含"Y"表示true"N" false,""表示null值.

但是我得到一个警告:unreachable code case _ => StringUtils.EMPTY.获取默认值的正确方法也正确匹配？

def parseMetrics(metric: Metric): List[String] = {
    import scala.collection.JavaConverters._
    val metricKeys: Seq[String] = getMetricKeys
    val matricsData = metric.transactionMap.asScala

metricKeys.map(key => key -> matricsData.getOrElse(key, null))
      .toMap.values.map(Predef.Boolean2boolean).collect  {
      case true => "Y"
      case false => "N"
      case _ => StringUtils.EMPTY
    }.toList
}

我需要使用bat文件将源文件复制到目标文件夹。

我创建了这个：

@echo off

set source="D:\Folder1\file.dll"
set destination="D:\Test\TestCopy*\Test\"
xcopy /s /y %source%  %destination%
pause

我的目标路径是TestCopy.2.5.3.6。这个数字可以改变。所以指定TestCopy*不起作用。指定TestCopy.*.*.*.*也不起作用。

我该如何解决？

我试图从列表中取出一对的第一个和第二个元素，以便可以对其求和。这是我的代码，我不确定为什么会出错

func :: [(Double,Double)] -> (Double,Double)
func [(x, y)] = map fst (x,y)

use crate::List::{Cons, Nil};

#[derive(Debug)]
struct Foo {}

#[derive(Debug)]
enum List {
    Cons(i32, Foo),
    Nil,
}

impl List {
    fn tail(&self) -> Option<&Foo> {
        match self {
            Cons(_, item) => Some(item), // why `item` is of type `&Foo`?
            Nil => None,
        }
    }
}

如评论中所述，为什么是item类型&Foo？说的item是类型&Foo而不是类型的规则是什么Foo？

我理解项目是没有意义的Foo; &self表示self引用是参考，因此将值从引用中移出是没有意义的，但是是否有任何明确定义规则的规范？

假设我有一个结构：

data MyType 
  = CV Int 
  | CA MyType MyType
  | CI
  | CD
  | CB

我有一个期望MyType的函数，我只想匹配以下语法子集：

data MyTypeNoCV 
  = CA MyType MyType
  | CI
  | CD
  | CB

我知道这在Haskell中是不可能的。有没有一种方法可以对结构进行参数化以某种方式标记节点？

Data.Void可能有帮助吗？

我有一个方法，需要以一年（int）作为参数。根据传入的年份，我需要分配一个变量，然后在查询中使用该变量：

def findByYear (year: Int): Future[Int] = {
  val tableName = ""
  year match {
    case 1970 => tableName = "table1970" //this errors out
    case 1980 => tableName = "table1980" //this errors out
  }
  config.db.run {
    sqlu"SELECT count(*) from #${tableName}"
  }
}

由于scala不允许重新分配，因此出现了以上错误。有没有更好的方法来执行此操作，而不是将config.db.run子句放在每个子句中，case后者将成为非常重复的代码？

根据理解，模式匹配不起作用。

我在课本“ Scala中编程”中阅读了模式匹配的概念。

我有一个模式匹配的定义，如下所示。

def checkMe (a:Any) =  a match {
      case Int => "I am an Integer"
      case Double => "I am a Double"
      case Char => "I am a Charecter"
      case _ => "I am something else"
     }

无论我在调用该函数时传递了什么，总是执行默认情况。

例如：checkMa（100）给出“我是别的东西” checkMe（10。）也给出“我是别的东西”等。

有人可以帮我理解定义中的错误吗。

我希望定义根据我通过的类型执行。