Agda'da Kağıt Üzerine İdeada Toplam Parsers Uygulamak

Question

this paper numaralı telefondan, Idris ile toplam ayrıştırıcıları uygulamaya çalışıyorum. Önce daha temel tanıyıcı türünü P uygulamaya çalışmıştır:

Tok : Type 
Tok = Char 

mutual 
    data P : Bool -> Type where 
    fail : P False 
    empty : P True 
    sat : (Tok -> Bool) -> P False 
    (<|>) : P n -> P m -> P (n || m) 
    (.) : LazyP m n -> LazyP n m -> P (n && m) 
    nonempty : P n -> P False 
    cast : (n = m) -> P n -> P m 

    LazyP : Bool -> Bool -> Type 
    LazyP False n = Lazy (P n) 
    LazyP True n = P n 

DelayP : P n -> LazyP b n 
DelayP {b = False} x = Delay x 
DelayP {b = True } x = x 

ForceP : LazyP b n -> P n 
ForceP {b = False} x = Force x 
ForceP {b = True } x = x 

Forced : LazyP b n -> Bool 
Forced {b = b} _ = b 

Bu iyi çalışır, ama kağıttan ilk örneği tanımlamak nasıl çalışamaz.

left-right : P false 
left-right = ♯ left-right . ♯ left-right 

Ama bu İdris'i çalışmak için alınamıyor: Agda sırf

lr : P False 
lr = (Delay lr . Delay lr) 

böyle, o biraz yardım eğer typecheck olacak

Can't unify 
    Lazy' t (P False) 
with 
    LazyP n m 

üretir:

lr : P False 
lr = (the (LazyP False False) (Delay lr)) . (the (LazyP False False) (Delay lr)) 

Ancak bu reddedildi Ben ♯ operatör Agda içinde nasıl bağlandığını tamamen emin değilim yardımcı olmuyor

lr : P False 
lr = Delay (the (LazyP True False) lr) . (the (LazyP False False) (Delay lr)) 

gibi diğer varyantları olduğu gibi, Bütünlük denetleyici tarafından ed.

Idris'da sol-sağ tanıtıcıyı tanımlamanın bir yolu var mı? P tanımım yanlış mı, yoksa işlevi tercüme etme girişimi mi? Ya da Idris'un bütünlük kontrolörü, bu dolandırıcılık işine kadar değil mi?

Answer 1

Şu anda bu kütüphaneyi kendim denemeye çalışıyorum, Agda'nın Idris'a farklı etkileri olduğunu düşünüyor. Bunlar eksik implicits:

%default total 

mutual 
    data P : Bool -> Type where 
    Fail : P False 
    Empty : P True 
    Tok : Char -> P False 
    (<|>) : P n -> P m -> P (n || m) 
    (.) : {n,m: Bool} -> LazyP m n -> LazyP n m -> P (n && m) 

    LazyP : Bool -> Bool -> Type 
    LazyP False n = Inf (P n) 
    LazyP True n = P n 

lr : P False 
lr = (.) {n=False} {m=False} (Delay lr) (Delay lr)