anchor.diff:      let toValueStr (x:string) = RedisValue.op_Implicit(x:string)
       let toValueI64 (x:int64) = RedisValue.op_Implicit(x:int64)
       let toValueI32 (x:int32) = RedisValue.op_Implicit(x:int32)
  +    let fromValueStr (x:RedisValue):string = RedisValue.op_Implicit (x)
  +    let fromValueI64 (x:RedisValue):int64 = Int64.Parse (RedisValue.op_Implicit (x))
  +    let fromValueI32 (x:RedisValue):int = Int32.Parse (RedisValue.op_Implicit (x))
   
   module Async =
       let inline awaitPlainTask (task: Task) = 
  
positive.code:         }
      member x.pause () = async { raise (NotImplementedException ()) }
      member x.resume () = async { raise (NotImplementedException ()) }
      member x.on () = async { raise (NotImplementedException ()) }
      member x.count () = async { raise (NotImplementedException ()) }
      member x.empty () = async { raise (NotImplementedException ()) }
      member x.getJob (id:string) = async { raise (NotImplementedException ()) }
negative.code: 
  and Queue<'a> (name, db:IDatabase) as this =
      let event = new Event<OxenEvent<'a>> ()
      let processStalledJob job = async { () }
      let processStaledJobs () = 
          async {
              let! range = db.ListRangeAsync (this.toKey ("active"), 0L, -1L) |> Async.AwaitTask
              let jobs = 
                  range 
                  |> Seq.map fromValueStr
                  |> Seq.map RedisKey.op_Implicit
                  |> Seq.map (fun x -> Job.fromId (this, x))
              return! jobs |> Async.Parallel
          }
  
      member x.toKey (kind:string) = RedisKey.op_Implicit ("bull:" + name + ":" + kind)
      member x.client = db
      member x.process (handler:(Job<'a> * unit -> unit) -> unit) = () //process is reserved for future use
  