Package parser-all: The whole stream parser

Information

name	parser-all
version	1.67
description	The whole stream parser
author	Joe Hurd <joe@gilith.com>
license	MIT
requires	bool list natural option pair parser-comb parser-stream
show	Data.Bool Data.List Data.Option Data.Pair Number.Natural Parser Parser.Stream

Files

Package tarball parser-all-1.67.tgz
Theory file parser-all.thy (included in the package tarball)

Defined Constant

Parser
- parseStream

Theorems

⊦ ∀p. parseStream p eof = eof

⊦ ∀p. parseStream p error = error

⊦ ∀p s. length (parseStream p s) ≤ length s

⊦ ∀p e l.
inverse p e ⇒ parseStream p (fromList (concat (map e l))) = fromList l

⊦ ∀p e x s.
inverse p e ⇒ parseStream p (append (e x) s) = cons x (parseStream p s)

⊦ ∀p e s.
    strongInverse p e ⇒
    case toList (parseStream p s) of
      none → ⊤
    | some l → toList s = some (concat (map e l))

⊦ ∀p a s.
    parseStream p (cons a s) =
    case destParser p a s of
      none → error
    | some (b, s') → cons b (parseStream p s')

Input Type Operators

→
bool
Data
- List
  - list
- Option
  - option
- Pair
  - ×
Number
- Natural
  - natural
Parser
- parser
- Stream
  - stream

Input Constants

=
select
Data
- Bool
  - ∀
  - ∧
  - ⇒
  - ∃
  - ∨
  - ¬
  - ⊥
  - ⊤
- List
  - ::
  - @
  - []
  - concat
  - map
- Option
  - case
  - none
  - some
- Pair
  - ,
Number
- Natural
  - ≤
  - suc
  - zero
Parser
- destParser
- inverse
- parse
- strongInverse
- Stream
  - append
  - case
  - cons
  - eof
  - error
  - fromList
  - isProperSuffix
  - isSuffix
  - length
  - toList

Assumptions

⊦ ⊤

⊦ length eof = 0

⊦ length error = 0

⊦ concat [] = []

⊦ toList error = none

⊦ ∀t. t ⇒ t

⊦ ∀n. 0 ≤ n

⊦ ∀n. n ≤ n

⊦ ⊥ ⇔ ∀p. p

⊦ toList eof = some []

⊦ ∀x. ¬isProperSuffix x x

⊦ (¬) = λp. p ⇒ ⊥

⊦ (∃) = λp. p ((select) p)

⊦ ∀t. (λx. t x) = t

⊦ (∀) = λp. p = λx. ⊤

⊦ ∀a'. ¬(none = some a')

⊦ ∀t. ⊤ ∧ t ⇔ t

⊦ ∀t. ⊥ ⇒ t ⇔ ⊤

⊦ ∀t. ⊤ ⇒ t ⇔ t

⊦ ∀t. t ⇒ ⊤ ⇔ ⊤

⊦ ∀s. append [] s = s

⊦ ∀f. map f [] = []

⊦ ∀p. parse p eof = none

⊦ ∀p. parse p error = none

⊦ ∀l. fromList l = append l eof

⊦ (⇒) = λp q. p ∧ q ⇔ p

⊦ ∀b f. case b f none = b

⊦ ∀p x. p x ⇒ p ((select) p)

⊦ ∀xy. ∃x y. xy = (x, y)

⊦ ∀a s. length (cons a s) = suc (length s)

⊦ ∀x. x = none ∨ ∃a. x = some a

⊦ (∧) = λp q. (λf. f p q) = λf. f ⊤ ⊤

⊦ ∀e b f. case e b f eof = b

⊦ ∀e b f. case e b f error = e

⊦ (∃) = λp. ∀q. (∀x. p x ⇒ q) ⇒ q

⊦ ∀a a'. some a = some a' ⇔ a = a'

⊦ ∀m n. suc m ≤ suc n ⇔ m ≤ n

⊦ ∀h t. concat (h :: t) = h @ concat t

⊦ ∀x y. isSuffix x y ⇒ length x ≤ length y

⊦ ∀b f a. case b f (some a) = f a

⊦ ∀l. l = [] ∨ ∃h t. l = h :: t

⊦ (∨) = λp q. ∀r. (p ⇒ r) ⇒ (q ⇒ r) ⇒ r

⊦ ∀s s'. isSuffix s s' ⇔ s = s' ∨ isProperSuffix s s'

⊦ ∀f. ∃fn. ∀x y. fn (x, y) = f x y

⊦ ∀p a s. parse p (cons a s) = destParser p a s

⊦ ∀h t s. append (h :: t) s = cons h (append t s)

⊦ ∀m n p. m ≤ n ∧ n ≤ p ⇒ m ≤ p

⊦ ∀x y z. append (x @ y) z = append x (append y z)

⊦ ∀p. (∀x. ∃y. p x y) ⇔ ∃y. ∀x. p x (y x)

⊦ ∀a s.
toList (cons a s) =
case toList s of none → none | some l → some (a :: l)

⊦ ∀l s.
toList (append l s) =
case toList s of none → none | some ls → some (l @ ls)

⊦ ∀f h t. map f (h :: t) = f h :: map f t

⊦ ∀s a s'. isProperSuffix s (cons a s') ⇔ s = s' ∨ isProperSuffix s s'

⊦ ∀x. x = error ∨ x = eof ∨ ∃a₀ a₁. x = cons a₀ a₁

⊦ ∀p. (∀x. (∀y. isProperSuffix y x ⇒ p y) ⇒ p x) ⇒ ∀x. p x

⊦ ∀e b f a s. case e b f (cons a s) = f a s

⊦ ∀p q. (∀x. p x ∧ q x) ⇔ (∀x. p x) ∧ ∀x. q x

⊦ ∀p. p [] ∧ (∀h t. p t ⇒ p (h :: t)) ⇒ ∀l. p l

⊦ ∀p a s b s'. destParser p a s = some (b, s') ⇒ isSuffix s' s

⊦ ∀x y a b. (x, y) = (a, b) ⇔ x = a ∧ y = b

⊦ ∀a₀ a₁ a0' a1'. cons a₀ a₁ = cons a0' a1' ⇔ a₀ = a0' ∧ a₁ = a1'

⊦ ∀p e. inverse p e ⇔ ∀x s. parse p (append (e x) s) = some (x, s)

⊦ ∀p s.
parse p s = none ∨
∃b s'. parse p s = some (b, s') ∧ isProperSuffix s' s

⊦ ∀p a s.
destParser p a s = none ∨
∃b s'. destParser p a s = some (b, s') ∧ isSuffix s' s

⊦ ∀p e.
strongInverse p e ⇔
inverse p e ∧ ∀s x s'. parse p s = some (x, s') ⇒ s = append (e x) s'

⊦ ∀h.
(∀f g s. (∀s'. isProperSuffix s' s ⇒ f s' = g s') ⇒ h f s = h g s) ⇒
∃f. ∀s. f s = h f s