anchor.diff:      let toValueI32 (x:int32) = RedisValue.op_Implicit(x:int32)
       /// make RedisValue from float
       let toValueFloat (x:float) = RedisValue.op_Implicit(x:float)
  -    ///get int from RedisValue
  -    let fromValueI32 (x:RedisValue):int = x |> int
  -    ///get int64 from RedisValue
  -    let fromValueI64 (x:RedisValue):int64 = x |> int64
  -    ///get string from RedisValue
  -    let fromValueString (x:RedisValue):string = x |> string
  -    ///get float from RedisValue
  -    let fromValueFloat (x:RedisValue):float = x |> float
       /// get RedisValue from RedisKey with a long in the middle
       let valueToKeyLong (x:RedisValue):RedisKey = RedisKey.op_Implicit(int64(x).ToString ())
       /// get RedisChannel from RedisKey
  
positive.code:             return Job.fromData (
                  queue, 
                  jobId,
                  jobHash("data").Value.Value |> fromValueString, 
                  jobHash("opts").Value.Value |> fromValueString, 
                  jobHash("progress").Value.Value |> fromValueI32,
                  jobHash("timestamp").Value.Value |> fromValueFloat,
                  match jobHash("delay") with
                  | None -> None
                  | Some x when x.Value |> fromValueString = "undefined" -> None
                  | Some x when x.Value |> fromValueFloat = 0. -> None
                  | Some x -> x.Value |> fromValueFloat |> Some)
          }
  
      /// create a job from a redis hash
  
negative.code:                 newJobChannel,
                  (fun c v -> 
                      async {
                          let jobId = v |> int64
                          return! this.emitNewJobEvent(jobId)
                      } |> Async.RunSynchronously))
      
  