anchor.diff:                  match t with
                  
                       | Num -> 
  -                        yield OpConstant(tid, id, value |> getDwords)
  +                        match value with
  +                            | :? float as v when doubleAsFloat ->
  +                                yield OpConstant(tid, id, v |> float32 |> getDwords)
  +                            | _ -> 
  +                                yield OpConstant(tid, id, value |> getDwords)
   
                       | Bool ->
                           if unbox value then yield OpConstantTrue(tid, id)
  
positive.code:                     match t with
                          | None -> return! Expr.Call(pi.GetMethod, indices) |> compileExpression last 
                          | Some t -> return! Expr.Call(t, pi.GetMethod, indices) |> compileExpression last
  
                              
                  | _ ->
                      return failwithf "unsupported expr: %A" e
  
          }
  
  
  
      let testCode = 
          <@ 
              if (0 < 2 |> not) && 3 > 2 then 1 else 2
          @>
  
      let runTest() =
          let res = compileExpression true testCode 
          let (s,_) = res.build SpirVState.Empty
  
  
          let str = InstructionPrinter.toString ((RevList.toList s.typeInstructions) @ (RevList.toList s.instructions))
          printfn "%s" str
negative.code:                             // variable we skip its initialization
                              | FixedArrayType(et,d), NewObject(_) ->
                                  let! tid = compileType (makePtrType v.Type)
                                  let! vid = newMutableVarId v
                                  yield OpVariable(tid, vid, StorageClass.Function, None)
  
                              | _ ->
                                  if v.IsMutable then
                                      let! tid = compileType (makePtrType v.Type)
                                      let! vid = newMutableVarId v
                                      let! e = compileExpression false e
                                      yield OpVariable(tid, vid, StorageClass.Function, Some e)
                                  else
  