anchor.diff:                              selfList.Write ws "Children" args
   
                   let reader (rs : ReadState) : Expr =
  -                    failwith ""
  +                    let kind = Pickler.string.Read rs "Kind"
  +                    match kind with
  +                        | "Var" ->
  +                            let v = varPickler.Read rs "Var"
  +                            Expr.Var v
  +
  +                        | "Lambda" ->
  +                            let v = varPickler.Read rs "Var"
  +                            let b = self.Read rs "Body"
  +                            Expr.Lambda(v,b)
  +
  +                        | "Comb" ->
  +                            let o = infoPickler.Read rs "Info"
  +                            let c = selfList.Read rs "Children"
  +                            RebuildShapeCombination(o, c)
  +                            
  +                        | _ ->
  +                            failwithf "invalid expression kind: %A" kind
   
                   Pickler.FromPrimitives(reader, writer)
               )
   
           do registry.RegisterFactory varPickler
              registry.RegisterFactory exprPickler
  -
  +            
           let cache = PicklerCache.FromCustomPicklerRegistry registry
           let murmur = MurMur3() :> IHashStreamFactory
           let pickler = FsPickler.CreateBinarySerializer(picklerResolver = cache)
  
positive.code:                 let rec writer (ws : WriteState) (e : Expr) =
              
                      match Reflection.withAttributes e [] with    
                          | NewTuple [String "DebugRange"; _] ->
                              ()
  
                          | NewTuple [String "Method"; _] ->
                              ()
  
                          | ShapeVar v -> 
                              Pickler.string.Write ws "Kind" "Var"
                              varPickler.Write ws "Var" v
  
  
                          | ShapeLambda(v, b) ->
                              Pickler.string.Write ws "Kind" "Lambda"
  
negative.code: 
                  
          static member ComputeHash(e : Expr) =
              let e = Reflection.withAttributes e []
  
              use s = Pickler.murmur.Create()
              Pickler.pickler.Serialize(s, e)
  