Pertanyaan Apa yang dimaksud dengan “beberapa” dan “banyak” dari Alternatif?


Alternative, perpanjangan dari Applicative, menyatakan empty, <|> dan dua fungsi ini:

Satu atau lebih:

some :: f a -> f [a]

Nol atau lebih:

many :: f a -> f [a]

Jika didefinisikan, some dan many harus menjadi solusi persamaan terkecil:

some v = (:) <$> v <*> many v

many v = some v <|> pure []

Saya tidak bisa menemukan contoh untuk itu some dan many didefinisikan. Apa artinya dan penggunaan praktisnya? Apakah mereka digunakan sama sekali? Saya tidak dapat memahami tujuan mereka hanya dari definisi ini.

Memperbarui: Saya tidak bertanya apa itu Alternative, apa adanya some dan many


32
2017-08-07 16:23


asal


Jawaban:


Saya cenderung melihatnya Applicative parser perpustakaan kombinator.

a :: Parser [String]
a = some (string "hello")

dan saya melihat many digunakan untuk tujuan dalam definisi default dari Parsing di parsers.

Saya pikir Parsec menjadi contoh utama dari perpustakaan parser combinator menyembunyikan penggunaan some/many karena itu mengubah hal-hal seperti (<|>).


13
2017-08-07 17:25



Contoh contoh dasar: dengan

import Control.Monad(Functor(..))
import Control.Applicative
import Data.Char

-- char string parser
newtype P a = P { runP :: String -> [(a,String)] }

-- runP (P p) s = p s

instance Functor P where
  -- fmap :: (a -> b) -> f a -> f b
  fmap f (P q) = P (\s -> [ (f y,ys) | (y,ys) <- q s])

instance Applicative P where
  -- pure :: a -> f a
  pure x = P (\s -> [(x,s)])
  -- (<*>) :: f (a -> b) -> f a -> f b
  P p <*> P q = P (\s -> [(x y, ys) | (x,xs) <- p s, (y,ys) <- q xs])

letter = P p where      -- sample parser
  p (x:xs) | isAlpha x = [(x,xs)]
  p _ = []

kita punya

*Main Data.Char> runP letter "123"
[]
*Main Data.Char> runP letter "a123"
[('a',"123")]
*Main Data.Char> runP ( (:) <$> letter <*> pure []) "a123"
[("a","123")]
*Main Data.Char> runP ( (:) <$> letter <*> ((:)<$>letter <*> pure []) ) "a123"
[]
*Main Data.Char> runP ( (:) <$> letter <*> ((:)<$>letter <*> pure []) ) "ab123"
[("ab","123")]   -- NOT NICE ^^^^^^^^^^^^^^^^^^^^ -}

Kemudian, dengan

instance Alternative P where
  -- (<|>) :: f a -> f a -> f a
  P p <|> P q = P (\s-> p s ++ q s)
  -- empty :: f a   -- the identity of <|>
  empty = P (\s-> [])

kita mendapatkan

*Main Data.Char> runP (many letter) "ab123"
[("ab","123"),("a","b123"),("","ab123")]
*Main Data.Char> runP (some letter) "ab123"
[("ab","123"),("a","b123")]

*Main Data.Char> runP (optional letter) "ab123"
[(Just 'a',"b123"),(Nothing,"ab123")]
*Main Data.Char> runP (optional letter) "123"
[(Nothing,"123")]

Prelude Main Data.Traversable> runP (sequenceA $ replicate 2 letter) "ab123"
[("ab","123")]               --  NICE  ^^^^^^^^^^^^^^^^^^^
-}

11
2017-08-07 18:12



Dalam STM Applicative, some akan berarti: Teruslah mencoba hingga berhasil setidaknya sekali, dan kemudian teruslah melakukannya sampai gagal. many akan berarti: Lakukan ini sebanyak yang Anda bisa sampai kegagalan.


8
2017-08-07 21:36



Akan memberikan contoh yang baik memotivasi penggunaan metode tersebut, tetapi Anda tampaknya masih memiliki kesalahpahaman tentang jenis kelas.

Definisi tipe kelas mencantumkan jenis tanda tangan untuk metode yang ada untuk semua contoh dari kelas tipe. Ini mungkin juga menyediakan implementasi standar metode-metode itu, yang terjadi dengan Alternative's beberapa dan banyak metode.

Agar menjadi instance yang valid, semua metode harus ditentukan untuk instance. Jadi yang Anda temukan itu tidak secara khusus tentukan contoh untuk beberapa atau banyak menggunakan default implementasi, dan kode untuk mereka persis seperti yang tercantum dalam pertanyaan Anda.

Jadi, untuk lebih jelas, beberapa dan banyak memang didefinisikan dan dapat digunakan dengan semua Alternatif contoh berkat definisi default yang diberikan dengan definisi kelas jenis.


4
2017-08-07 20:08