anchor.diff:          return Fable.Test(unionExpr, kind, r)
     }
   
  +let private isRasingMatchFailureExpr (expr: FSharpExpr) = 
  +    match expr with 
  +    | BasicPatterns.Call(None, methodInfo, [ ], [unitType], [value]) ->   
  +        match methodInfo.FullName with 
  +        | "Microsoft.FSharp.Core.Operators.raise" -> 
  +            match value with 
  +            | BasicPatterns.NewRecord(recordType, [ BasicPatterns.Const (value, valueT) ; rangeFrom; rangeTo ]) -> 
  +                match recordType.TypeDefinition.FullName with 
  +                | "Microsoft.FSharp.Core.MatchFailureException"-> Some (value.ToString())
  +                | _ -> None
  +            | _ -> None 
  +        | _ -> None 
  +    | _ -> None  
  +
  +/// Creates a "throw Error({errorMessage})" expression
  +let private createThrowErrorExpr (errorMessage: string) range : Fable.Expr = 
  +    let errorCallExpr = 
  +        let errorArgInfo : Fable.ArgInfo = {
  +            ThisArg = None
  +            Args = [Fable.Value(Fable.StringConstant errorMessage)]
  +            SignatureArgTypes = Fable.NoUncurrying
  +            Spread = Fable.NoSpread 
  +            IsBaseOrSelfConstructorCall = false
  +        } 
  +
  +        let errorId : Fable.Ident = {
  +            Name = "Error"
  +            Type = Fable.Any
  +            Kind = Fable.UnspecifiedIdent
  +            IsMutable = false 
  +            IsCompilerGenerated = true
  +            Range = None
  +        }
  +
  +        Fable.Call(Fable.CallKind.ConstructorCall(Fable.Expr.IdentExpr errorId), errorArgInfo)
  +    
  +    // Todo: add range information
  +    Fable.Throw(Fable.Operation(errorCallExpr, Fable.Type.Any, None), Fable.Type.Any, range)
  +
   let private transformExpr (com: IFableCompiler) (ctx: Context) fsExpr =
     trampoline {
       match fsExpr with
  
positive.code:                     let! expr = transformExpr com ctx expr
                      return! transformDecisionTargets ((idents, expr)::acc) tail
              }
          let! decisionTargets = transformDecisionTargets [] decisionTargets
          return Fable.DecisionTree(decisionExpr, decisionTargets)
  
      | BasicPatterns.DecisionTreeSuccess(targetIndex, boundValues) ->
          let! boundValues = transformExprList com ctx boundValues
  
negative.code: 
      // Pattern Matching
      | BasicPatterns.DecisionTree(decisionExpr, decisionTargets) ->
          let! fableDecisionExpr = transformExpr com ctx decisionExpr 
          let rec transformDecisionTargets acc xs =
              trampoline {
                  match xs with
  