转换其中一个<；错误，选项<；X>&燃气轮机；选择<；要么<；错误，X>&燃气轮机；在c#LanguageExt中

我用的是C语言文字

我有一个从一些Json解析的类

MyDto

。解析函数返回

或
。
如果dto与给定的规则匹配，或者它是一个错误，那么我希望返回结果，否则，什么也没有

最终结果应为
选项类型

最后我吃了这样的东西

Option<Either<Error, MyDto>> finalResult =  
     MyDto.From("some json") // Returns Either<Error, MyDto>
          .Right(dto => (dto.Equals("something")
             ? Some<Either<Error, IDhResponse>>(Right(dto))
             : None))
          .Left(error => Some<Either<Error, IDhResponse>>(Left(error)));

选项最终结果=
From（“somejson”）//返回
.Right（dto=>（dto.Equals（“某物”）
？一些（右（dto））
：无）
.Left（error=>Some（Left（error））；

我真的不喜欢它，因为它有太多的重复

然后我试了这个

MyDto.From("some json") // Returns Either<Error, MyDto>
   .Map(dto => dto.Equals("something")
      ? Some(dto)
      : None)

MyDto.From（“某些json”）//返回
.Map（dto=>dto.Equals（“某物”）
？一些（dto）
：无）

但它返回
或者
，如果此时我能够将选项带出来的话，看起来还不错。不幸的是，我找不到任何能做到这一点的东西

有什么存在吗？还是有更好的方法来实现我的目标

也许像

 MyDto.From("some json") // Returns Either<Error, MyDto>
   .Where(dto => dto.Equals("something")) // Only applies to Right branch and wrap everything in  Option when fails

MyDto.From（“某些json”）//返回
.Where（dto=>dto.Equals（“something”）//仅适用于右分支，并在失败时将所有内容包装到选项中

感谢您对此提供的任何建议。
好的，以下是三种代码解决方案：

Either<Exception, int> resultOfParsing = Right(10); // Left(new Exception("error"))

// version 1: make use of "bottom" state:
Either<Exception, int> filterResultUsingBottom = resultOfParsing.Filter(i => i > 5);

var textResultUsingBottom = filterResultUsingBottom.Match(i => $"success: {i}", exception => $"error: {exception.Message}", () => "condition: false");

// version 2: inner option
Either<Exception, Option<int>> filterResultInnerOption = resultOfParsing
    .Map(i => Some(i))
    .FilterT(i => i > 5);

var textResultInnerOption = filterResultInnerOption.Match(noError =>
        noError.Match(i => $"success: {i}", () => "condition: false"),
    exception => $"error: {exception.Message}");

// version 3: outer option
Option<Either<Exception, int>> filterResultOuterOption = filterResultInnerOption.Sequence();

var textResultOuterOption = filterResultOuterOption.Match(noConditionFail =>
        noConditionFail.Match(i => $"success: {i}", exception => $"error: {exception.Message}"),
    () => "condition: false");

resultOfParsing=Right（10）；//左（新异常（“错误”））
//版本1：使用“底部”状态：
filterResultUsingBottom=resultOfParsing.Filter（i=>i>5）；
var textResultUsingBottom=filterResultUsingBottom.Match（i=>$“成功：{i}”，异常=>$“错误：{exception.Message}”，（）=>“条件：false”）；
//版本2：内部选项
filterResultInnerOption=resultOfParsing
.Map（i=>Some（i））
.FilterT（i=>i>5）；
var textResultInnerOption=FilterResultinElection.Match（noError=>
noError.Match（i=>$“success:{i}”，（）=>“condition:false”），
异常=>$“错误：{exception.Message}”）；
//版本3：外部选项
Option filterResultOuterOption=FilterResultinRoption.Sequence（）；
var textResultOuterOption=filterResultOuterOption.Match（noConditionFail=>
noConditionFail.Match（i=>$“成功：{i}”，异常=>$“错误：{exception.Message}”），
（）=>“条件：假”）；

正如您所看到的，所有版本都可以以类似的方式使用（带有
匹配的行
）。您应该根据希望在程序中拥有/传递的类型选择所需的版本

如果您不太关心“条件失败”和“异常”之间的区别，那么版本1（底部）可能是可以的（避免类型嵌套）。但我个人更喜欢后者。您可以根据需要使用
.Sequence（）
在它们之间切换。
好的，下面是三种代码解决方案：

Either<Exception, int> resultOfParsing = Right(10); // Left(new Exception("error"))

// version 1: make use of "bottom" state:
Either<Exception, int> filterResultUsingBottom = resultOfParsing.Filter(i => i > 5);

var textResultUsingBottom = filterResultUsingBottom.Match(i => $"success: {i}", exception => $"error: {exception.Message}", () => "condition: false");

// version 2: inner option
Either<Exception, Option<int>> filterResultInnerOption = resultOfParsing
    .Map(i => Some(i))
    .FilterT(i => i > 5);

var textResultInnerOption = filterResultInnerOption.Match(noError =>
        noError.Match(i => $"success: {i}", () => "condition: false"),
    exception => $"error: {exception.Message}");

// version 3: outer option
Option<Either<Exception, int>> filterResultOuterOption = filterResultInnerOption.Sequence();

var textResultOuterOption = filterResultOuterOption.Match(noConditionFail =>
        noConditionFail.Match(i => $"success: {i}", exception => $"error: {exception.Message}"),
    () => "condition: false");

resultOfParsing=Right（10）；//左（新异常（“错误”））
//版本1：使用“底部”状态：
filterResultUsingBottom=resultOfParsing.Filter（i=>i>5）；
var textResultUsingBottom=filterResultUsingBottom.Match（i=>$“成功：{i}”，异常=>$“错误：{exception.Message}”，（）=>“条件：false”）；
//版本2：内部选项
filterResultInnerOption=resultOfParsing
.Map（i=>Some（i））
.FilterT（i=>i>5）；
var textResultInnerOption=FilterResultinElection.Match（noError=>
noError.Match（i=>$“success:{i}”，（）=>“condition:false”），
异常=>$“错误：{exception.Message}”）；
//版本3：外部选项
Option filterResultOuterOption=FilterResultinRoption.Sequence（）；
var textResultOuterOption=filterResultOuterOption.Match（noConditionFail=>
noConditionFail.Match（i=>$“成功：{i}”，异常=>$“错误：{exception.Message}”），
（）=>“条件：假”）；

正如您所看到的，所有版本都可以以类似的方式使用（带有
匹配的行
）。您应该根据希望在程序中拥有/传递的类型选择所需的版本

如果您不太关心“条件失败”和“异常”之间的区别，那么版本1（底部）可能是可以的（避免类型嵌套）。但我个人更喜欢后者。您可以根据需要使用
.Sequence（）
在它们之间切换。
非常感谢您的回答！可能序列就是我要找的。我将在星期一试一试。谢谢你的回答！可能序列就是我要找的。我将在星期一试一试。谢谢