Ответ 1
Я просто отправлю FromInt32. В идеальном мире мы могли бы определить его просто как
let inline FromInt32 i =
((^t or int) : (static member op_Explicit : int -> ^t) i)
который использовал бы статические ограничения, чтобы обеспечить явное преобразование из int. К сожалению, есть две проблемы. Во-первых, синтаксис недействителен - вы не можете иметь конкретный тип (например, int) в разделе "static-typars" ограничения члена. Мы можем обойти это, определив вспомогательную функцию
let inline cvt i = ((^t or ^u) : (static member op_Explicit : ^u -> ^t) i)
let inline FromInt32 (i:int) = cvt i
Поскольку обе эти функции встроены, это не менее эффективно, чем первая попытка, это просто слово.
Здесь, где мы сталкиваемся со второй проблемой: это будет работать для реальных определений op_Explicit (или op_Implicit, которые обрабатываются специально компилятором, чтобы он был включен op_Explicit). Итак, (10G : bigint) будет вложен так, как если бы вы написали System.Numerics.BigInt.op_Implicit 10, что так же эффективно, как мы можем надеяться. Однако F # также имитирует op_Explicit для многих примитивных типов (например, для преобразований от int до float, byte и т.д.), А так как определение FromInt32 основывается на существовании этих членов, оно будет сбой во время выполнения (т.е. (10G : float) и даже (10G : int) будет компилироваться, но будет генерировать исключение при выполнении). В идеале будущая версия F # может позволить этому работать как есть, но с F # 2.0 нам нужно придумать обходной путь.
Было бы неплохо, если бы мы могли использовать аналогичный подход к тому, как основная библиотека F # справляется с такой проблемой, что потребует специальной оболочки всех подразумеваемых операторов, но приведет к тому, что все будет встроено с максимальной эффективностью:
let inline FromInt32 (i : int) : ^t =
cvt i
when ^t : int = int i
when ^t : float = float i
when ^t : byte = byte i
...
Однако компилятор F # отклоняет это сообщение с "Static optimization conditionals are only for use within the F# library" (а компиляция с секретным флагом --compiling-fslib только ухудшает ситуацию:)).
Вместо этого нам нужно использовать несколько дополнительных слоев косвенности для достижения чего-то подобного во время выполнения. Во-первых, мы создадим сопоставление типов во время выполнения с функциями преобразования с помощью статического члена родового типа:
type IntConverterDynamicImplTable<'t>() =
static let result : int -> 't =
let ty = typeof< 't> //'
if ty.Equals(typeof<sbyte>) then sbyte |> box |> unbox
elif ty.Equals(typeof<int16>) then int16 |> box |> unbox
elif ty.Equals(typeof<int32>) then int |> box |> unbox
elif ty.Equals(typeof<int64>) then int64 |> box |> unbox
elif ty.Equals(typeof<nativeint>) then nativeint |> box |> unbox
elif ty.Equals(typeof<byte>) then byte |> box |> unbox
elif ty.Equals(typeof<uint16>) then uint16 |> box |> unbox
elif ty.Equals(typeof<char>) then char |> box |> unbox
elif ty.Equals(typeof<uint32>) then uint32 |> box |> unbox
elif ty.Equals(typeof<uint64>) then uint64 |> box |> unbox
elif ty.Equals(typeof<unativeint>) then unativeint |> box |> unbox
elif ty.Equals(typeof<decimal>) then decimal |> box |> unbox
elif ty.Equals(typeof<float>) then float |> box |> unbox
elif ty.Equals(typeof<float32>) then float32 |> box |> unbox
else
let m =
try ty.GetMethod("op_Implicit", [| typeof<int> |])
with _ -> ty.GetMethod("op_Explicit", [| typeof<int> |])
let del =
System.Delegate.CreateDelegate(typeof<System.Func<int,'t>>, m)
:?> System.Func<int,'t>
del.Invoke |> box |> unbox
static member Result = result
Это похоже на то, что мы пытались достичь с помощью статических условий оптимизации в предыдущей попытке, но откладывается на время выполнения вместо всего, что оценивается во время компиляции. Теперь нам просто нужно определить несколько значений для использования этого типа:
let inline constrain< ^t, ^u when (^t or ^u) : (static member op_Explicit : ^t -> ^u)> () = ()
let inline FromInt32 i : ^t =
constrain<int, ^t>()
IntConverterDynamicImplTable.Result i
Здесь функция constrain используется только для проверки того, что FromInt32 может применяться только к типам, где есть явное преобразование из int (или имитируется компилятором). Фактический вызов constrain() внутри FromInt32 должен быть оптимизирован во время компиляции.
При таком подходе (10G : bigint) будет скомпилирован примерно как IntConverterDynamicImplTable<bigint>.Result 10, а IntConverterDynamicTable<bigint>.Result будет иметь значение, эквивалентное (System.Func<int,bigint>(bigint.op_Implicit)).Invoke (но кэшируется, так что делегат создается только один раз). Точно так же (10G : int64) будет компилироваться в IntConverterDynamicImplTable<int64>.Result 10, а IntConverterDynamicTable<int64>.Result будет иметь значение, эквивалентное функции преобразования (int64 : int -> int64), поэтому есть накладные расходы на несколько вызовов методов, но общая производительность должна быть очень хорошей.
ИЗМЕНИТЬ
Однако, если вы просто ищете что-то более эффективное, чем наивные реализации FromInt32 и FromInt64, занимающие время O (n), здесь версия, которая по-прежнему относительно проста и принимает только O (log n) время:
module SymmetricOps =
let inline (~-) (x:'a) : 'a = -x
let inline (+) (x:'a) (y:'a) : 'a = x + y
let inline (-) (x:'a) (y:'a) : 'a = x - y
let inline (*) (x:'a) (y:'a) : 'a = x * y
let inline (/) (x:'a) (y:'a) : 'a = x / y
let inline (%) (x:'a) (y:'a) : 'a = x % y
module NumericLiteralG =
open SymmetricOps
let inline FromOne() = LanguagePrimitives.GenericOne
let inline FromZero() = LanguagePrimitives.GenericZero
let rec compute zero one two (/) (%) Two (+) (-) (*) pow2 rest n =
if n = zero then rest
else
let rest' =
let nmod2 = n % two
if nmod2 = zero then rest
elif nmod2 = one then rest + pow2
else rest - pow2
compute zero one two (/) (%) Two (+) (-) (*) (Two * pow2) rest' (n / two)
let inline FromInt32 i = compute 0 1 2 (/) (%) (FromOne() + FromOne()) (+) (-) (*) (FromOne()) (FromZero()) i
let inline FromInt64 i = compute 0L 1L 2L (/) (%) (FromOne() + FromOne()) (+) (-) (*) (FromOne()) (FromZero()) i