Named deconstructors that can fail.

[mrange]

I asked on twitch about Deconstructors that can fail and Kathleen D suggested I post a question here.

I am looking for Named deconstructors that can fail. I am obviously inspired by F# Active patterns and Scala unapply. These are powerful techniques to allow custom pattern matching.

My code examples are quite rubbish but I thought it might be better to supply some examples to help start a thinking process.

Example:

I have the need to parse GraphQL, visitor classes are pain. Pattern matching over the syntax tree is preferable IMHO.

I would like my code to look something like this:

switch (syntaxNode) 
{
  // Try to deconstruct using the DocumentDeconstructor
  case var Document(definitions): 
    // Do stuff
    break;
  // Try to deconstruct using the OperationDefinitionDeconstructor
  case var OperationDefinition(kind, _, name, operation, selectionSet, variableDefinitions, directives): 
    // Do stuff
    break;
  // Some other cases...
}

The GraphQL syntaxNode has a common base class for all nodes in the syntax tree. With pattern matching you test if the type and extract the relevant variables from the syntax node.

One possible way to implement this could be have Deconstruct scoped by a class

// Naming convention *Deconstructor for named deconstructor suggested
public static class DocumentDeconstructor
{
    // Deconstruct returns bool to allow pattern matching to fail.
    public static bool Deconstruct(
        this ISyntaxNode                    sn
      , out Kind_Document                   kind
      , out Location?                       location
      , out IReadOnlyList<IDefinitionNode>  definitions
      )
    {
      kind        = new Kind_Document(false)  ;
      location    = default                   ;
      definitions = s_definitionNodes         ;
      if (sn is DocumentNode node)
      {
        kind        = new Kind_Document(true) ;
        location    = node.Location           ;
        definitions = node.Definitions        ;
        return true;
      }
      return false;
    }
}

Another case for this is to help implement union types. Something I miss dearly from F#, Scala, Haskell and so on.

I have tried to emulate it in existing version of C# but it is clunky

      switch(sn)
      {
        // I need to test on kind in order to support failing Deconstructs. In order to get type safety I get a lot of overhead
        // In addition; I can't get it work if I want to deconstruct different cases with the same number of arguments
        case var (kind, _, definitions) when kind.IsDocument:
          // Do stuff
          break;
        case var (kind, _, name, operation, selectionSet, variableDefinitions, directives) when kind.IsOperationDefinition:
          // Do stuff
          break;
      }
    }

There are also arguments to allow passing input args to Deconstructors.

Very very hand-wavy code

var myRegex = new Regex(...);
switch(myString)
{
  // Deconstruct Regu
  case  var myRegex(groups):
  {
     // If regex is successful groups now contains the matched groups
  }
}

What about type patterns

Supposedly type tests could work as well but pattern matching would be more flexible and if C# supported nested deconstruction that could enable even more powerful ways to traverse a syntax tree.

      // Nested deconstructors that can fail can lead to powerful ways to deconstruct trees
      sn switch 
      {
        var Argument (_, "top"      , IntValue    (_, Int(v))) => Top (v)
        var Argument (_, "skip"     , IntValue    (_, Int(v))) => Skip(v)
        var Argument (_, "take"     , IntValue    (_, Int(v))) => Take(v)
        var Argument (_, "orderBy"  , ObjectValue (_, fs))     => OrderBy(fS)
        _ => throw new Exception("oops");
      }

Links:

Active Patterns F# - https://fsharpforfunandprofit.com/posts/convenience-active-patterns/
Scala unapply - https://www.tutorialspoint.com/scala/scala_extractors.htm
Scala regex unapplySeq - https://www.scala-lang.org/api/2.12.1/scala/util/matching/Regex.html

[333fred]

See #1047 and #4131.

[SK-Genius]

#4815