fsharp/src/FSharp.Core/Measure.fs at 517b393c1e02e318a742eb21e5f5862ca2d6dc44 · dotnet/fsharp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
namespace Microsoft.FSharp.Core

open System.ComponentModel

[<Sealed; AbstractClass; EditorBrowsable(EditorBrowsableState.Never)>]
type Measure =
    static member inline Tag(value: byte) : byte<'Measure> =
        LanguagePrimitives.ByteWithMeasure value

    static member inline Tag(value: sbyte) : sbyte<'Measure> =
        LanguagePrimitives.SByteWithMeasure value

    static member inline Tag(value: int16) : int16<'Measure> =
        LanguagePrimitives.Int16WithMeasure value

    static member inline Tag(value: uint16) : uint16<'Measure> =
        LanguagePrimitives.UInt16WithMeasure value

    static member inline Tag(value: int) : int<'Measure> =
        LanguagePrimitives.Int32WithMeasure value

    static member inline Tag(value: uint) : uint<'Measure> =
        LanguagePrimitives.UInt32WithMeasure value

    static member inline Tag(value: int64) : int64<'Measure> =
        LanguagePrimitives.Int64WithMeasure value

    static member inline Tag(value: uint64) : uint64<'Measure> =
        LanguagePrimitives.UInt64WithMeasure value

    static member inline Tag(value: nativeint) : nativeint<'Measure> =
        LanguagePrimitives.IntPtrWithMeasure value

    static member inline Tag(value: unativeint) : unativeint<'Measure> =
        LanguagePrimitives.UIntPtrWithMeasure value

    static member inline Tag(value: float) : float<'Measure> =
        LanguagePrimitives.FloatWithMeasure value

    static member inline Tag(value: float32) : float32<'Measure> =
        LanguagePrimitives.Float32WithMeasure value

    static member inline Tag(value: decimal) : decimal<'Measure> =
        LanguagePrimitives.DecimalWithMeasure value

    static member inline InvokeTag value : '``T<'Measure>`` =
        let inline call_2 (_: ^a, b: ^b) =
            ((^a or ^b): (static member Tag: _ -> _) b)

        call_2 (Unchecked.defaultof<Measure>, value)

    static member inline Untag(value: byte<'Measure>) =
        byte value

    static member inline Untag(value: sbyte<'Measure>) =
        sbyte value

    static member inline Untag(value: int16<'Measure>) =
        int16 value

    static member inline Untag(value: uint16<'Measure>) =
        uint16 value

    static member inline Untag(value: int<'Measure>) =
        int value

    static member inline Untag(value: uint<'Measure>) =
        uint value

    static member inline Untag(value: int64<'Measure>) =
        int64 value

    static member inline Untag(value: uint64<'Measure>) =
        uint64 value

    static member inline Untag(value: nativeint<'Measure>) =
        nativeint value

    static member inline Untag(value: unativeint<'Measure>) =
        unativeint value

    static member inline Untag(value: float<'Measure>) =
        float value

    static member inline Untag(value: float32<'Measure>) =
        float32 value

    static member inline Untag(value: decimal<'Measure>) =
        decimal value

    static member inline InvokeUntag value : 'T =
        let inline call_2 (_: ^a, b: ^b) =
            ((^a or ^b): (static member Untag: _ -> _) b)

        call_2 (Unchecked.defaultof<Measure>, value)

[<RequireQualifiedAccess>]
module Measure =
    /// Tags a value with a unit of measure.
    let inline tag (value: 'T) : '``T<'Measure>`` =
        Measure.InvokeTag value

    /// Removes a unit of measure from a value.
    let inline untag (value: '``T<'Measure>``) : 'T =
        Measure.InvokeUntag value

    /// Tags a value with a new unit of measure.
    let inline retag (value: '``T<'Measure1>``) : '``T<'Measure2>`` =
        tag (untag value: 'T)

    /// Maps a value with a unit of measure to another value with a unit of measure.
    let inline map ([<InlineIfLambda>] mapping: 'T -> 'U) (value: '``T<'Measure1>``) : '``U<'Measure2>`` =
        tag (mapping (untag value))