Я просто адрес 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" message (и компиляция с секретным флагом --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