Можно ли определить статический класс, содержащий перегружаемые члены в F #? let привязки модулей нельзя перегружать, даже если они скомпилированы в статические статические элементы в статических классах.
type declerations могут содержать статические члены, но я не знаю, может ли сам тип быть статическим.
Мое текущее решение - определить type с помощью частного конструктора и просто использовать его. Мне интересно, есть ли способ определить статический тип, как я хочу.
Как отметил Роберт Джеппсон, "статический класс" на С# является лишь короткой рукой для создания класса, который не может быть создан или унаследован, и имеет только статические члены. Вот как вы можете выполнить именно это в F #:
[<AbstractClass; Sealed>]
type MyStaticClass private () =
static member SomeStaticMethod(a, b, c) =
(a + b + c)
static member SomeStaticMethod(a, b, c, d) =
(a + b + c + d)
Это может быть немного излишним, поскольку как AbstractClass, так и частный конструктор помешают вам создать экземпляр класса, однако это то, что делают статические классы С# - они скомпилированы в абстрактный класс с частным конструктором. Атрибут Sealed не позволяет наследовать этот класс.
Этот метод не вызовет ошибку компилятора, если вы добавите методы экземпляра, как это было бы на С#, но с точки зрения вызывающего нет никакой разницы.
Я не уверен, что есть такая вещь, как статический класс. "Статический" на уровне класса в С# был представлен в 2.0, я считаю, в основном как удобство (избегайте частных конструкторов и проверки времени компиляции, чтобы не присутствовали члены экземпляра). Вы не можете изучить тип и сделать вывод, что он статичен: http://msdn.microsoft.com/en-us/library/system.reflection.typeinfo.aspx
Обновление: MSDN объявляет, что статический класс - это класс, который запечатан и имеет только статические члены: http://msdn.microsoft.com/en-us/library/79b3xss3(v=vs.80).aspx
Итак, что вы делаете в данный момент, это способ сделать это.
В F # нет возможности для определения статических типов.
Первым альтернативом является определение модуля, но он не имеет возможности перегружать функции (это то, что вам нужно). Второй вариант - объявить нормальный тип со статическими членами.
Что касается второго подхода, это именно то, что принятый ответ для вашего старого описанного вопроса. Я реорганизую код, чтобы объяснить это проще. Во-первых, определены фиктивные однократные раздельные объединения:
type Overloads = Overloads
Во-вторых, вы используете тот факт, что статические члены могут быть перегружены:
type Overloads with
static member ($) (Overloads, m1: #IMeasurable) = fun (m2: #IMeasurable) -> m1.Measure + m2.Measure
static member ($) (Overloads, m1: int) = fun (m2: #IMeasurable) -> m1 + m2.Measure
В-третьих, вы распространяете ограничения этих перегруженных методов на ограничения, используя ключевое слово inline:
let inline ( |+| ) m1 m2 = (Overloads $ m1) m2
Когда вы можете перегрузить let-bounds с помощью этого метода, вы должны создать модуль-оболочку для хранения этих функций и пометить свой тип private.
Это объясняется в Принципы проектирования компонентов F #.
[<AbstractClass; Sealed>]
type Demo =
static member World = "World"
static member Hello() = Demo.Hello(Demo.World)
static member Hello(name: string) = sprintf "Hello %s!" name
let s1 = Demo.Hello()
let s2 = Demo.Hello("F#")
По-прежнему можно определить методы экземпляра, но вы не можете создавать экземпляр класса, когда нет конструктора.
Я думаю, что проблема здесь заключается в том, чтобы сделать F # на С#. Если проблема не может быть решена не обязательно, используйте С# или напишите объектно-ориентированную библиотеку и используйте ее в F #.