Sepengetahuan saya, ada notasi khusus untuk tipe Option dan List di F#. Misalnya, Option<'a> sama dengan menulis 'a option, demikian juga untuk 'a list dan FSharpList<'a>.

Apakah kata kunci bahasa tertentu ini, atau ada cara untuk menentukan jenis khusus yang dapat menggunakan notasi "pasca-perbaikan" dengan cara yang sama seperti list dan option?

f#
4
Massimiliano 20 September 2019, 04:57

1 menjawab

Jawaban Terbaik

Anda dapat melakukan ini untuk semua tipe F# yang ingin Anda definisikan. Anda tidak mendapatkan versi huruf kecil otomatis dari nama Anda... tetapi kemudian, tipe bawaan F# juga tidak: di FSharp.Core/prim-types.fs dalam kode sumber F#, ada definisi type 'a list = List<'a>, itulah sebabnya anda dapat menulis int list daripada List<int>.

Dan Anda dapat menggunakan Foo<'a> atau 'a Foo (atau 'a foo) saat Anda menentukan tipe Anda juga. Satu-satunya aturan adalah Anda harus mencocokkan gaya casing yang Anda gunakan saat menentukan jenisnya. Berikut sesi F# Interactive untuk didemonstrasikan:

> type Foo<'a> = 'a list ;;
type Foo<'a> = 'a list

> type 'a bar = 'a list ;;
type 'a bar = 'a list

> let x : int Foo = [] ;;
val x : Foo<int> = []

> let y : Foo<int> = [] ;;
val y : Foo<int> = []

> let z : int bar = [] ;;
val z : int bar = []

> let w : bar<int> = [] ;;
val w : int bar = []

Tetapi Anda harus cocok dengan casing dari jenis yang Anda tentukan:

> let x : int foo = [] ;;

  let x : int foo = [] ;;
  ------------^^^

error FS0039: The type 'foo' is not defined. Maybe you want one of the following:
   Foo
   Foo`1

> let y : Bar<int> = [] ;;

  let y : Bar<int> = [] ;;
  --------^^^

error FS0039: The type 'Bar' is not defined. Maybe you want one of the following:
   bar
   bar`1

Perhatikan bahwa kita mendapatkan Foo<int> sebagai tipe yang tercantum dalam tanggapan F# Interactive apakah kita mendefinisikan tipe kita sebagai int Foo atau Foo<int>. Ini tidak didasarkan pada kasus (atas atau bawah) yang kami gunakan untuk menentukan jenisnya, tetapi lebih pada urutan awalan/postfix yang kami gunakan:

> type foo<'a> = 'a list ;;
type foo<'a> = 'a list

> type 'a bar = 'a list ;;
type 'a bar = 'a list

> let x : 'a foo = [] ;;
val x : foo<'a>

> let y : 'a bar = [] ;;
val y : 'a bar

Jadi begitulah. Anda dapat menggunakan sintaks ini untuk tipe Anda sendiri tanpa melakukan sesuatu yang istimewa. Satu-satunya aturan adalah bahwa tipe harus mengambil tepat satu parameter umum: Anda tidak dapat melakukan type d = int,string Dictionary. Untuk tipe yang menggunakan dua atau lebih parameter umum, Anda harus mendefinisikannya dengan gaya Dictionary<int,string>.

5
rmunn 20 September 2019, 02:29