master..c083497 · syntax

git.iko.soy/syntax

on c083497 help sign in

Data/Syntax.hs+12−89

since splitsnapshots

unifiedsplit

@@ -10,28 +10,23 @@ License : MIT

10Maintainer : Paweł Nowak <pawel834@gmail.com>

11Stability : experimental

13−Reversible parsing and pretty-printing.

13+Abstract syntax descriptions based on semi-isomorphisms.

14-}

15module Data.Syntax (

16 -- * Syntax.

17 Syntax(..),

18− Isolable(..),

19 -- * Common isomorphisms.

18 -- * Common isomorphisms.

20 packed

19 packed

21 ) where

20 ) where

23−import Prelude hiding (take, takeWhile, id, (.))

22+import Prelude hiding (take, takeWhile)

25−import Control.Category

26−import Control.Category.Reader

24+import Control.Category.Reader

27−import Control.Category.Structures

28−import Control.Lens.Iso

25+import Control.Lens.Iso

29−import Control.Lens.SemiIso

26+import Control.Lens.SemiIso

30−import Control.SIArrow

27+import Control.SIArrow

31−import Data.MonoTraversable

28+import Data.MonoTraversable

32−import Data.Sequences hiding (take, takeWhile, replicate)

29+import Data.Sequences hiding (take, takeWhile)

33−import qualified Data.Vector as V

34−import qualified Data.Vector.Unboxed as VU

36-- | An isomorphism between a sequence and a list of its elements.

31-- | An isomorphism between a sequence and a list of its elements.

37packed :: IsSequence seq => Iso' seq [Element seq]

32packed :: IsSequence seq => Iso' seq [Element seq]

@@ -39,11 +34,11 @@ packed = iso otoList fromList

40-- | An abstract syntax description based on semi-isomorphisms.

35-- | An abstract syntax description based on semi-isomorphisms.

41--

36--

42−-- This class can be implemented by both parsers and printers.

37+-- This class can be implemented by both parsers and printers (and maybe more?).

43−--

38+--

44-- The usual use is to write a polymorphic syntax description and instantiate it

39-- The usual use is to write a polymorphic syntax description and instantiate it

45−-- both as a parser and a printer. Examples are available in 'syntax-example' and

40+-- both as a parser and a printer. An example is available in the 'syntax-example'

46−-- 'syntax-example-json' packages.

41+-- package.

47--

42--

48-- Methods of this class try to mimic "Data.Attoparsec.Text" interface.

43-- Methods of this class try to mimic "Data.Attoparsec.Text" interface.

49class ( SIArrow syn

44class ( SIArrow syn

@@ -99,58 +94,6 @@ class ( SIArrow syn

99 takeTill1 :: (Element (Seq syn) -> Bool) -> syn () (Seq syn)

94 takeTill1 :: (Element (Seq syn) -> Bool) -> syn () (Seq syn)

100 takeTill1 p = takeWhile1 (not . p)

95 takeTill1 p = takeWhile1 (not . p)

101

102− -- | Constant size vector. The default implementation uses lists, but

103− -- "syntax-attoparsec" and "syntax-printer" override it with an efficient

104− -- implementation that works on a vector directly.

105− --

106− -- @vecN n e@ describes a size @n@ vector with elements @e@.

107− --

108− -- Also see 'Data.Syntax.Combinator.vec'.

109− vecN :: Int -> syn () a -> syn () (V.Vector a)

110− vecN n e = packed /$/ sireplicate n e

111−

112− -- | Constant size vector with index-aware element. The default implementation

113− -- uses lists, but "syntax-attoparsec" and "syntax-printer" override it with an

114− -- efficient implementation that works on a vector directly.

115− --

116− -- @ivecN n e@ describes a size @n@ vector with elements @e@. Each element

117− -- gets its index and should output a value and the index unchanged.

118− --

119− -- Also see 'Data.Syntax.Combinator.ivec'.

120− ivecN :: Int -> syn Int (Int, a) -> syn () (V.Vector a)

121− ivecN n e = (packed /$/)

122− $ sisequence

123− $ map (\(i, e') -> constant i ^>> e'

124− >>> first (sipure (constant i))

125− >># unit . swapped)

126− $ zip [0 .. n-1] (replicate n e)

127−

128− -- | Constant size unboxed vector. The default implementation uses lists, but

129− -- "syntax-attoparsec" and "syntax-printer" override it with an efficient

130− -- implementation that works on a vector directly.

131− --

132− -- @vecN n e@ describes a size @n@ vector with elements @e@.

133− --

134− -- Also see 'Data.Syntax.Combinator.vec'.

135− uvecN :: VU.Unbox a => Int -> syn () a -> syn () (VU.Vector a)

136− uvecN n e = packed /$/ sireplicate n e

137−

138− -- | Constant size unboxed vector with index-aware element. The default implementation

139− -- uses lists, but "syntax-attoparsec" and "syntax-printer" override it with an

140− -- efficient implementation that works on a vector directly.

141− --

142− -- @ivecN n e@ describes a size @n@ vector with elements @e@. Each element

143− -- gets its index and should output a value and the index unchanged.

144− --

145− -- Also see 'Data.Syntax.Combinator.ivec'.

146− uivecN :: VU.Unbox a => Int -> syn Int (Int, a) -> syn () (VU.Vector a)

147− uivecN n e = (packed /$/)

148− $ sisequence

149− $ map (\(i, e') -> constant i ^>> e'

150− >>> first (sipure (constant i))

151− >># unit . swapped)

152− $ zip [0 .. n-1] (replicate n e)

153−

154 {-# MINIMAL anyChar #-}

97 {-# MINIMAL anyChar #-}

155

156instance Syntax syn => Syntax (ReaderCT env syn) where

99instance Syntax syn => Syntax (ReaderCT env syn) where

@@ -166,23 +109,3 @@ instance Syntax syn => Syntax (ReaderCT env syn) where

166 takeWhile1 = clift . takeWhile1

109 takeWhile1 = clift . takeWhile1

167 takeTill = clift . takeTill

110 takeTill = clift . takeTill

168 takeTill1 = clift . takeTill1

111 takeTill1 = clift . takeTill1

169− vecN n e = ReaderCT $ vecN n . runReaderCT e

170− ivecN n e = ReaderCT $ ivecN n . runReaderCT e

171− uvecN n e = ReaderCT $ uvecN n . runReaderCT e

172− uivecN n e = ReaderCT $ uivecN n . runReaderCT e

173−

174−-- | Execute a computation in an isolated context.

175−--

176−-- The motivating example: you want to write a function

177−--

178−-- > serializeList :: Syntax syn => syn () a -> syn () [a]

179−--

180−-- Notice that we cannot just use simany, because the first @syn () a@

181−-- could eat the entire sequence (even though we printed more than 1 value!), so

182−-- we have to insert some kind of separators between the element. But how can we

183−-- be sure that @syn () a@ will not eat our separators? We can't! Thats why we

184−-- have to do the parsing in two stages: first extract the sequence between separators,

185−-- then run the @syn () a@ on this sequence.

186−class Syntax syn => Isolable syn where

187− -- | Turns a computation into one executed in an isolated context.

188− isolate :: syn () b -> syn (Seq syn) b

Data/Syntax/Char.hs−1

@@ -26,7 +26,6 @@ module Data.Syntax.Char (

26 ) where

28import Control.Category.Reader

29−import Control.Category.Structures

30import Control.Lens.SemiIso

29import Control.Lens.SemiIso

31import Control.SIArrow

30import Control.SIArrow

32import Data.Bits

31import Data.Bits

Data/Syntax/Combinator.hs+11−149

@@ -1,6 +1,3 @@

1−{-# LANGUAGE RankNTypes #-}

2−{-# LANGUAGE ScopedTypeVariables #-}

3−{-# LANGUAGE FlexibleContexts #-}

4{- |

1{- |

5Module : Data.Syntax.Combinator

2Module : Data.Syntax.Combinator

6Description : Combinators that work with any sequence type.

3Description : Combinators that work with any sequence type.

@@ -12,50 +9,11 @@ Stability : experimental

13Combinators that work with any sequence type.

10Combinators that work with any sequence type.

14-}

11-}

15−module Data.Syntax.Combinator

12+module Data.Syntax.Combinator where

16− (

17− -- * Combinators.

18− optional,

19− opt,

20− opt_,

21− choice,

22− eitherOf,

24− -- * Lists.

14+import Control.Lens

25− manyTill,

26− sepBy,

27− sepBy1,

28−

29− -- * Arrowized combinators.

30− takeArr,

31−

32− -- * Vectors.

33− vecNSepBy,

34− ivecNSepBy,

35− vec,

36− vecSepBy,

37− ivec,

38− ivecSepBy,

39−

40− -- * Unboxed vectors.

41− uvecNSepBy,

42− uivecNSepBy,

43− uvec,

44− uvecSepBy,

45− uivec,

46− uivecSepBy

47− ) where

48−

49−import Control.Category

50−import Control.Category.Structures

51−import Control.Lens

52−import Control.Lens.SemiIso

15+import Control.Lens.SemiIso

53−import Control.SIArrow

16+import Control.SIArrow

54−import qualified Data.MonoTraversable as Seq

55−import Data.Syntax

56−import qualified Data.Vector as V

57−import qualified Data.Vector.Unboxed as VU

58−import Prelude hiding (id, (.), take)

60-- | One or zero occurences of @f@.

18-- | One or zero occurences of @f@.

61optional :: SIArrow cat => cat () a -> cat () (Maybe a)

19optional :: SIArrow cat => cat () a -> cat () (Maybe a)

@@ -70,15 +28,6 @@ opt_ :: SIArrow cat => cat () () -> cat () ()

70opt_ f = semiIso (const (Left "opt_")) Right /$/ f

28opt_ f = semiIso (const (Left "opt_")) Right /$/ f

71 /+/ sipure id

29 /+/ sipure id

73−-- | Tries to apply the actions in the list in order, until one of

74−-- them succeeds. Returns the value of the succeeding action.

75−choice :: SIArrow cat => [cat () a] -> cat () a

76−choice = foldr (/+/) (sifail "choice: all alternatives failed")

77−

78−-- | Combine two alternatives.

79−eitherOf :: SIArrow cat => cat () a -> cat () b -> cat () (Either a b)

80−eitherOf a b = _Left /$/ a /+/ _Right /$/ b

81−

82-- | @manyTill p end@ applies action p zero or more times until action

31-- | @manyTill p end@ applies action p zero or more times until action

83-- end succeeds, and returns the list of values returned by p.

32-- end succeeds, and returns the list of values returned by p.

84manyTill :: SIArrow cat => cat () a -> cat () () -> cat () [a]

33manyTill :: SIArrow cat => cat () a -> cat () () -> cat () [a]

@@ -93,98 +42,11 @@ sepBy v s = sepBy1 v s /+/ sipure _Empty

93sepBy1 :: SIArrow cat => cat () a -> cat () () -> cat () [a]

42sepBy1 :: SIArrow cat => cat () a -> cat () () -> cat () [a]

94sepBy1 v s = _Cons /$/ v /*/ (s */ sepBy1 v s /+/ sipure _Empty)

43sepBy1 v s = _Cons /$/ v /*/ (s */ sepBy1 v s /+/ sipure _Empty)

96−-- | A string of given length.

45+-- | Tries to apply the actions in the list in order, until one of

97−takeArr :: Syntax syn => syn Int (Seq syn)

46+-- them succeeds. Returns the value of the succeeding action.

98−takeArr = sibind $ iso (\n -> constant n #>> take n)

47+choice :: SIArrow cat => [cat () a] -> cat () a

99− (\s -> constant (Seq.olength s) #>> take (Seq.olength s))

48+choice = foldr (/+/) (sifail "choice: all alternatives failed")

100−

101−-- | Constant size vector with separators.

102−--

103−-- @vecNSepBy n e sep@ describes a size @n@ vector with elements @e@ separated by @sep@.

104−vecNSepBy :: Syntax syn => Int -> syn () a -> syn () () -> syn () (V.Vector a)

105−vecNSepBy n e sep = ivecNSepBy n (unit ^>> second e) sep

106−

107−-- | Constant size vector with separators and index-aware elements.

108−--

109−-- @ivecNSepBy n e sep@ describes a size @n@ vector with elements @e@ separated by @sep@.

110−-- Each element gets its index and should output a value and the index unchanged.

111−ivecNSepBy :: Syntax syn => Int -> syn Int (Int, a) -> syn () () -> syn () (V.Vector a)

112−ivecNSepBy n e sep = ivecN n $ sibind $ iso el (el . fst)

113− where

114− el k | k < n - 1 = unit ^>> e *** sep >># unit

115− | otherwise = e

116−

117−-- | Runtime sized vector. The size can depend on the result of some computation.

118−--

119−-- @vec e@ describes a vector with elements @e@.

120−vec :: Syntax syn => syn () a -> syn Int (V.Vector a)

121−vec e = vecSepBy e (siarr id)

122−

123−-- | Runtime sized vector with separators. The size can depend on the result of some

124−-- computation.

125−--

126−-- @vecSepBy e sep@ describes a vector with elements @e@ separated by @sep@.

127−vecSepBy :: Syntax syn => syn () a -> syn () () -> syn Int (V.Vector a)

128−vecSepBy e sep = ivecSepBy (unit ^>> second e) sep

129−

130−-- | Runtime sized vector with index-aware elements. The size can depend on the result

131−-- of some computation.

132−--

133−-- @ivec e@ describes a vector with elements @e@.

134−ivec :: Syntax syn => syn Int (Int, a) -> syn Int (V.Vector a)

135−ivec e = ivecSepBy e (siarr id)

136−

137−-- | Runtime sized vector with index-aware elements and separators. The size can depend

138−-- on the result of some computation.

139−--

140−-- @ivecSepBy e sep@ describes a vector with elements @e@ separated by @sep@.

141−ivecSepBy :: Syntax syn => syn Int (Int, a) -> syn () () -> syn Int (V.Vector a)

142−ivecSepBy e sep = sibind $ iso (\n -> constant n #>> ivecNSepBy n e sep)

143− (\v -> constant (V.length v) #>> ivecNSepBy (V.length v) e sep)

144−

145−-- | Constant size unboxed vector with separators.

146−--

147−-- @uvecNSepBy n e sep@ describes a size @n@ vector with elements @e@ separated by @sep@.

148−uvecNSepBy :: (Syntax syn, VU.Unbox a) => Int -> syn () a -> syn () () -> syn () (VU.Vector a)

149−uvecNSepBy n e sep = uivecNSepBy n (unit ^>> second e) sep

150−

151−-- | Constant size unboxed vector with separators and index-aware elements.

152−--

153−-- @uivecNSepBy n e sep@ describes a size @n@ vector with elements @e@ separated by @sep@.

154−-- Each element gets its index and should output a value and the index unchanged.

155−uivecNSepBy :: (Syntax syn, VU.Unbox a) => Int -> syn Int (Int, a)

156− -> syn () () -> syn () (VU.Vector a)

157−uivecNSepBy n e sep = uivecN n $ sibind $ iso el (el . fst)

158− where

159− el k | k < n - 1 = unit ^>> e *** sep >># unit

160− | otherwise = e

161−

162−-- | Runtime sized unboxed vector. The size can depend on the result of some computation.

163−--

164−-- @uvec e@ describes a vector with elements @e@.

165−uvec :: (Syntax syn, VU.Unbox a) => syn () a -> syn Int (VU.Vector a)

166−uvec e = uvecSepBy e (siarr id)

167−

168−-- | Runtime sized unboxed vector with separators. The size can depend on the result of some

169−-- computation.

170−--

171−-- @uvecSepBy e sep@ describes a vector with elements @e@ separated by @sep@.

172−uvecSepBy :: (Syntax syn, VU.Unbox a) => syn () a -> syn () () -> syn Int (VU.Vector a)

173−uvecSepBy e sep = uivecSepBy (unit ^>> second e) sep

174−

175−-- | Runtime sized unboxed vector with index-aware elements. The size can depend on the result

176−-- of some computation.

177−--

178−-- @uivec e@ describes a vector with elements @e@.

179−uivec :: (Syntax syn, VU.Unbox a) => syn Int (Int, a) -> syn Int (VU.Vector a)

180−uivec e = uivecSepBy e (siarr id)

181

182−-- | Runtime sized unboxed vector with index-aware elements and separators. The size can depend

50+-- | Combine two alternatives.

183−-- on the result of some computation.

51+eitherOf :: SIArrow cat => cat () a -> cat () b -> cat () (Either a b)

184−--

52+eitherOf a b = _Left /$/ a /+/ _Right /$/ b

185−-- @uivecSepBy e sep@ describes a vector with elements @e@ separated by @sep@.

186−uivecSepBy :: (Syntax syn, VU.Unbox a) => syn Int (Int, a)

187− -> syn () () -> syn Int (VU.Vector a)

188−uivecSepBy e sep = sibind $ iso (\n -> constant n #>> uivecNSepBy n e sep)

189− (\v -> constant (VU.length v)

190− #>> uivecNSepBy (VU.length v) e sep)

Data/Syntax/Indent.hs+4−5

@@ -10,7 +10,7 @@ License : MIT

10Maintainer : Paweł Nowak <pawel834@gmail.com>

11Stability : experimental

13−Provides a very simple indentation as a category transformer.

13+Provides a very simple indentation as a category transformer (a functor from Cat to Cat).

14-}

15module Data.Syntax.Indent (

16 Indent,

@@ -21,7 +21,6 @@ module Data.Syntax.Indent (

22import Control.Category

23import Control.Category.Reader

24−import Control.Category.Structures

25import Control.SIArrow

24import Control.SIArrow

26import Data.Syntax

25import Data.Syntax

27import Data.Syntax.Char

26import Data.Syntax.Char

@@ -29,10 +28,10 @@ import Data.Syntax.Combinator

29import Prelude hiding (takeWhile, take, id, (.))

28import Prelude hiding (takeWhile, take, id, (.))

31-- | Adds indentation to a syntax description.

30-- | Adds indentation to a syntax description.

32−newtype Indent cat a b = Indent { getIndent :: ReaderCT (Int, cat () ()) cat a b }

31+newtype Indent cat a b = Indent { unIndent :: ReaderCT (Int, cat () ()) cat a b }

33− deriving (Category, Products, Coproducts, CatPlus, SIArrow)

32+ deriving (Category, Products, Coproducts, CategoryPlus, SIArrow)

35−instance CatTrans Indent where

34+instance CategoryTrans Indent where

36 clift = Indent . clift

35 clift = Indent . clift

38-- Generalized newtype deriving cannot derive this :(

37-- Generalized newtype deriving cannot derive this :(

syntax.cabal+20−22

@@ -1,35 +1,33 @@

1name: syntax

2version: 1.0.0.0

3−synopsis: Reversible parsing and pretty-printing.

3+synopsis: Syntax descriptions for unified parsing and pretty-printing.

4description:

5− "syntax" allows you to write a single syntax description and instantiate is both as a parser and a pretty printer.

5+ 'syntax' allows you to write a single syntax description and instantiate is both as a parser and a pretty printer.

6 .

7− Syntax descriptions are written in applicative or arrow style. The library uses a custom typeclass hierarchy, provided

7+ The interface is based on a custom Functor\/Applicative\/Monad hierarchy, provided by the 'semi-iso' package. You fmap using

8− by the "semi-iso" package. Most of the time you will be using operators like '/$/', '/*/' and '/+/' (= '<|>'), just

8+ a semi-isomorphism instead of function. A semi-isomorphism is a isomorphism that can fail in both directions, with slightly

9− like parser combinators. When more power is needed - e.g. when the syntax depends on the parsed or printed value -

9+ weakened laws. It is worth to note that @Iso@s and @Prism@s from 'lens' are valid semi-isomorphisms :)

10− you turn to arrows.

11 .

10 .

12− Semi-isomorphisms from "semi-iso" are the basic building block of syntax descriptions. I recommend reading

11+ Once you write a description you can, for example turn it into an Attoparsec parser, or into a 'Data.Syntax.Printer.Text.Printer'.

13− the hackage page of "semi-iso" first, as it contains much more information.

14 .

12 .

15− Once you write a syntax description (polymorphic in the syntax category) you can instantiate it both as a parser or as

13+ See @syntax-example@ and @syntax-example-json@ for examples, @syntax-attoparsec@ and @syntax-printer@ for a parser/printer implementation.

16− a pretty-printer. The library "syntax-attoparsec" gives you the ability to extract an Attoparsec parser. Pretty-printing

17− is implemented by the "syntax-printer" library, which uses Text and ByteString builders. (Note that formatting is handled

18− by "syntax" itself, not by the printer library)

19 .

14 .

20− Advanced formatting and parsing (for example indentation, haskell layout rule) is implemented as category transformers

15+ The library was inspired by:

21− (similar to monad transformers). Currently only simple indentation is implemented (in "Data.Syntax.Indent") - basically

22− a reader category transformer that tracks current indentation level. I plan on implementing Haskell layout rule in the

23− future.

24 .

16 .

25− The library can work with both text and binary data. Alas, there are no binary combinators implemented yet.

17+ * Rendel, Tillmann, and Klaus Ostermann. "Invertible syntax descriptions: unifying parsing and pretty printing." ACM Sigplan Notices. Vol. 45. No. 11. ACM, 2010.

26− I will implement them when i have the time (but these category transformers look so much more interesting for now ;).

27 .

18 .

28− EXAMPLES! See @syntax-example@ and @syntax-example-json@ for examples.

19+ TODO:

29 .

20 .

30− * "syntax-example" implements a simple lambda calculus.

21+ * Research relative monads and relative monad transformers. Indent is basically a Reader monad over a syntax. How would a State monad look?

31 .

22 .

32− * "syntax-example-json" implements a json parser and pretty printer.

23+ * Try to implement Haskell layout rule.

24+ .

25+ * Combinators for binary data formats, vectors.

26+ .

27+ * Better error messages.

28+ .

29+ * Maybe an implementation of do notation for SemiIsoMonad with QuasiQuoters, like the codo notation for comonads.

30+

33license: MIT

31license: MIT

34license-file: LICENSE

32license-file: LICENSE

35author: Paweł Nowak

33author: Paweł Nowak

@@ -48,5 +46,5 @@ library

48 Data.Syntax.Char

46 Data.Syntax.Char

49 Data.Syntax.Combinator

47 Data.Syntax.Combinator

50 Data.Syntax.Indent

48 Data.Syntax.Indent

51− build-depends: base >= 4 && < 5, mono-traversable, lens >= 4, semi-iso >= 1, scientific >= 0.3, text, vector

49+ build-depends: base >= 4 && < 5, mono-traversable, lens >= 4, semi-iso >= 1.0.0.0, scientific >= 0.3, text

52 default-language: Haskell2010

50 default-language: Haskell2010