-{-# LANGUAGE ConstraintKinds #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE NoPolyKinds #-}
+{-# LANGUAGE ConstraintKinds #-} -- For Executable
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ViewPatterns #-}
module Symantic.Parser.Automaton.Instructions where
-- | 'Instr'uctions for the 'Automaton'.
data Instr input valueStack (exceptionStack::Peano) returnValue a where
-- | @('Ret')@ returns the value in a singleton value-stack.
- Ret :: Instr inp '[ret] es ret a
- -- | @('Push' x k)@ pushes @(x)@ on the value-stack and continues with the next 'Instr'uction @(k)@.
- Push :: InstrPure x -> Instr inp (x ': vs) es ret a -> Instr inp vs es ret a
+ Ret ::
+ Instr inp '[ret] es ret a
+ -- | @('Push' x k)@ pushes @(x)@ on the value-stack
+ -- and continues with the next 'Instr'uction @(k)@.
+ Push ::
+ InstrPure x ->
+ Instr inp (x ': vs) es ret a ->
+ Instr inp vs es ret a
-- | @('Pop' k)@ pushes @(x)@ on the value-stack.
- Pop :: Instr inp vs es ret a -> Instr inp (x ': vs) es ret a
- -- | @('LiftI2' f k)@ pops two values from the value-stack, and pushes the result of @(f)@ applied to them.
- LiftI2 :: InstrPure (x -> y -> z) -> Instr inp (z : vs) es ret a -> Instr inp (y : x : vs) es ret a
+ Pop ::
+ Instr inp vs es ret a ->
+ Instr inp (x ': vs) es ret a
+ -- | @('LiftI2' f k)@ pops two values from the value-stack,
+ -- and pushes the result of @(f)@ applied to them.
+ LiftI2 ::
+ InstrPure (x -> y -> z) ->
+ Instr inp (z : vs) es ret a ->
+ Instr inp (y : x : vs) es ret a
-- | @('Fail')@ raises an error from the exception-stack.
- Fail :: Instr inp vs ('Succ es) ret a
- -- | @('Commit' k)@ removes an exception from the exception-stack and continues with the next 'Instr'uction @(k)@.
- Commit :: Instr inp vs es ret a -> Instr inp vs ('Succ es) ret a
- -- | @('Catch' l r)@ tries the @(l)@ 'Instr'uction, if it raises an exception, catches it, pushes the input on the value-stack and continues with the @(r)@ 'Instr'uction.
- Catch :: Instr inp vs ('Succ es) ret a -> Instr inp (inp ': vs) es ret a -> Instr inp vs es ret a
- -- | @('Seek' k)@ removes the input from the value-stack and continues with the next 'Instr'uction @(k)@.
- Seek :: Instr inp vs es r a -> Instr inp (inp : vs) es r a
- -- | @('Tell' k)@ pushes the input @(inp)@ on the value-stack and continues with the next 'Instr'uction @(k)@.
- Tell :: Instr inp (inp ': vs) es ret a -> Instr inp vs es ret a
+ Fail ::
+ Instr inp vs ('Succ es) ret a
+ -- | @('Commit' k)@ removes an exception from the exception-stack
+ -- and continues with the next 'Instr'uction @(k)@.
+ Commit ::
+ Instr inp vs es ret a ->
+ Instr inp vs ('Succ es) ret a
+ -- | @('Catch' l r)@ tries the @(l)@ 'Instr'uction,
+ -- if it raises an exception, catches it,
+ -- pushes the input on the value-stack
+ -- and continues with the @(r)@ 'Instr'uction.
+ Catch ::
+ Instr inp vs ('Succ es) ret a ->
+ Instr inp (inp ': vs) es ret a ->
+ Instr inp vs es ret a
+ -- | @('Seek' k)@ removes the input from the value-stack
+ -- and continues with the next 'Instr'uction @(k)@.
+ Seek ::
+ Instr inp vs es r a ->
+ Instr inp (inp : vs) es r a
+ -- | @('Tell' k)@ pushes the input @(inp)@ on the value-stack
+ -- and continues with the next 'Instr'uction @(k)@.
+ Tell ::
+ Instr inp (inp ': vs) es ret a ->
+ Instr inp vs es ret a
-- | @('Case' l r)@.
- Case :: Instr inp (x ': vs) es r a -> Instr inp (y ': vs) es r a -> Instr inp (Either x y ': vs) es r a
- -- | @('Swap' k)@ pops two values on the value-stack, pushes the first popped-out, then the second, and continues with the next 'Instr'uction @(k)@.
- Swap :: Instr inp (x ': y ': vs) es r a -> Instr inp (y ': x ': vs) es r a
+ Case ::
+ Instr inp (x ': vs) es r a ->
+ Instr inp (y ': vs) es r a ->
+ Instr inp (Either x y ': vs) es r a
+ -- | @('Swap' k)@ pops two values on the value-stack,
+ -- pushes the first popped-out, then the second,
+ -- and continues with the next 'Instr'uction @(k)@.
+ Swap ::
+ Instr inp (x ': y ': vs) es r a ->
+ Instr inp (y ': x ': vs) es r a
-- | @('Choices' ps bs d)@.
- Choices :: [InstrPure (x -> Bool)] -> [Instr inp vs es ret a] -> Instr inp vs es ret a -> Instr inp (x ': vs) es ret a
- Call :: Addr ret -> Instr inp (x ': xs) ('Succ es) ret a -> Instr inp xs ('Succ es) ret a
- Jump :: Addr ret -> Instr inp '[] ('Succ es) ret a
- Label :: Addr ret -> Instr inp (xs) ('Succ es) ret a -> Instr inp xs ('Succ es) ret a
+ Choices ::
+ [InstrPure (x -> Bool)] ->
+ [Instr inp vs es ret a] ->
+ Instr inp vs es ret a ->
+ Instr inp (x ': vs) es ret a
+ Label ::
+ Addr ret ->
+ Instr inp xs ('Succ es) ret a ->
+ Instr inp xs ('Succ es) ret a
+ Call ::
+ Addr ret ->
+ Instr inp (x ': xs) ('Succ es) ret a ->
+ Instr inp xs ('Succ es) ret a
+ Jump ::
+ Addr ret ->
+ Instr inp '[] ('Succ es) ret a
-- ** Type 'InstrPure'
data InstrPure a
conditional ps bs (Automaton a) (Automaton default_) =
Automaton $ \k ->
-- TODO: join points
- a (Choices (InstrPureHaskell Functor.<$> ps) ((\b -> unAutomaton b k) Functor.<$> bs) (default_ k))
+ a (Choices (InstrPureHaskell Functor.<$> ps)
+ ((\b -> unAutomaton b k) Functor.<$> bs)
+ (default_ k))
instance Lookable (Automaton inp a) where
look (Automaton x) = Automaton $ \k ->
Tell (x (Swap (Seek k)))
-{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE ConstraintKinds #-} -- For Grammar
module Symantic.Parser.Grammar
( module Symantic.Parser.Grammar
, module Symantic.Parser.Grammar.Combinators
instance Show letName => Letable letName DumpComb where
def name x = DumpComb $
- Tree.Node ("def " <> show name) [unDumpComb x]
+ Tree.Node ("def "<>show name) [unDumpComb x]
ref rec name = DumpComb $
Tree.Node
( (if rec then "rec " else "ref ")
) []
instance Applicable DumpComb where
_f <$> x = DumpComb $ Tree.Node "<$>" [unDumpComb x]
- pure a = DumpComb $ Tree.Node ("pure "<>show a) []
+ pure a = DumpComb $ Tree.Node ("pure "<>showsPrec 10 a "") []
x <*> y = DumpComb $ Tree.Node "<*>" [unDumpComb x, unDumpComb y]
instance Alternable DumpComb where
empty = DumpComb $ Tree.Node "empty" []
Trans (OptimizeComb letName repr) repr where
trans = trans . unOptimizeComb
-type instance Output (OptimizeComb letName repr) = Comb repr
+type instance Output (OptimizeComb _letName repr) = Comb repr
instance Trans (OptimizeComb letName repr) (Comb repr) where
trans = unOptimizeComb
instance Trans (Comb repr) (OptimizeComb letName repr) where
-- Functor Homomorphism Law
f :<$> Pure x ->
-- trace "Functor Homomorphism Law" $
- Pure (f Hask.:@ x)
+ Pure (f Hask..@ x)
-- App Right Absorption Law
Empty :<*> _ ->
-- App Interchange Law
u :<*> Pure x ->
-- trace "App Interchange Law" $
- optimizeCombNode (Hask.Flip Hask.:@ (Hask.:$) Hask.:@ x :<$> u)
+ optimizeCombNode (Hask.Flip Hask..@ (Hask.:$) Hask..@ x :<$> u)
-- App Left Absorption Law
p :<* (_ :<$> q) ->
-- trace "App Left Absorption Law" $
-- Branch Fusion Law
Branch (Branch b Empty (Pure (trans -> lr))) Empty br ->
-- trace "Branch Fusion Law" $
- optimizeCombNode (Branch (optimizeCombNode (Pure (Hask.Haskell (ValueCode (Value v) c)) :<*> b)) Empty br)
+ optimizeCombNode (Branch (optimizeCombNode (Pure (Hask.Haskell (ValueCode (Value v) c)) :<*> b))
+ Empty br)
where
v Left{} = Left ()
v (Right r) = case getValue lr r of
-- Branch Distributivity Law
f :<$> Branch b l r ->
-- trace "Branch Distributivity Law" $
- optimizeCombNode (Branch b (optimizeCombNode ((Hask..@) (Hask..) f :<$> l)) (optimizeCombNode ((Hask..@) (Hask..) f :<$> r)))
+ optimizeCombNode (Branch b (optimizeCombNode ((Hask..@) (Hask..) f :<$> l))
+ (optimizeCombNode ((Hask..@) (Hask..) f :<$> r)))
-- Match Absorption Law
Match _ _ Empty d ->
-- Match Pure Law
Match ps bs (Pure (trans -> a)) d ->
-- trace "Match Pure Law" $
- foldr (\(trans -> p, b) next -> if getValue p (getValue a) then b else next) d (List.zip ps bs)
+ foldr (\(trans -> p, b) next ->
+ if getValue p (getValue a) then b else next
+ ) d (List.zip ps bs)
-- Match Distributivity Law
f :<$> Match ps bs a d ->
-- trace "Match Distributivity Law" $
- Match ps (optimizeCombNode . (f :<$>) Functor.<$> bs) a (optimizeCombNode (f :<$> d))
+ Match ps (optimizeCombNode . (f :<$>) Functor.<$> bs) a
+ (optimizeCombNode (f :<$> d))
{- Possibly useless laws to be tested
Empty :*> _ -> Empty
Empty :<* _ -> Empty
-- App Definition of *> Law
- Hask.Flip Hask.:@ Hask.Const :<$> p :<*> q ->
+ Hask.Flip Hask..@ Hask.Const :<$> p :<*> q ->
-- trace "EXTRALAW: App Definition of *> Law" $
p :*> q
-- App Definition of <* Law
-- by the Composition Law and Homomorphism Law)
f :<$> (g :<$> p) ->
-- trace "EXTRALAW: Functor Composition Law" $
- optimizeCombNode ((Hask.:.) Hask.:@ f Hask.:@ g :<$> p)
+ optimizeCombNode ((Hask.:.) Hask..@ f Hask..@ g :<$> p)
-- Applicable Failure Weakening Law
u :<* Empty ->
-- trace "EXTRALAW: App Failure Weakening Law" $
optimizeCombNode (optimizeCombNode (Look p) :$> x)
NegLook (p :$> _) -> optimizeCombNode (NegLook p)
- -- Pure merge optimisation
- -- Pure x :<*> Pure y -> Pure (x Hask.:@ y)
-}
x -> x
newtype Code a = Code { unCode :: TExpQ a }
-- * Class 'Haskellable'
--- | Final encoding of some Haskellable functions
--- useful for some optimizations in 'optGram'.
+-- | Final encoding of some Haskell functions
+-- useful for some optimizations in 'optimizeComb'.
class Haskellable (repr :: * -> *) where
(.) :: repr ((b->c) -> (a->b) -> a -> c)
($) :: repr ((a->b) -> a -> b)
right :: repr (r -> Either l r)
nothing :: repr (Maybe a)
just :: repr (a -> Maybe a)
--- instance Haskellable Identity
-- ** Type 'Haskellable'
--- | Initial encoding of 'Haskellable'
+-- | Initial encoding of 'Haskellable'.
data Haskell a where
Haskell :: ValueCode a -> Haskell a
(:.) :: Haskell ((b->c) -> (a->b) -> a -> c)
infixl 9 .@, :@
instance Show (Haskell a) where
showsPrec p = \case
- Haskell{} -> showString "Haskell"
- (:.) -> showString "(.)"
- (:$) -> showString "($)"
- (:@) f x ->
- showParen (p > 0)
- Fun.$ showString "(@) "
- Fun.. showsPrec 10 f
- Fun.. showString " "
- Fun.. showsPrec 10 x
- Const -> showString "const"
- Flip -> showString "flip"
- Id -> showString "id"
- Unit -> showString "()"
+ Haskell{} -> showString "Haskell"
+ (:.) -> showString "(.)"
+ (:$) -> showString "($)"
+ (:@) ((:.) :@ f) g ->
+ showParen (p >= 9)
+ Fun.$ showsPrec 9 f
+ Fun.. showString " . "
+ Fun.. showsPrec 9 g
+ (:@) f x ->
+ showParen (p >= 10)
+ Fun.$ showsPrec 10 f
+ Fun.. showString " "
+ Fun.. showsPrec 10 x
+ Const -> showString "const"
+ Flip -> showString "flip"
+ Id -> showString "id"
+ Unit -> showString "()"
instance Trans Haskell ValueCode where
trans = \case
- Haskell x -> x
- (:.) -> (.)
- (:$) -> ($)
- (:@) f x -> (.@) (trans f) (trans x)
- Const -> const
- Flip -> flip
- Id -> id
- Unit -> unit
+ Haskell x -> x
+ (:.) -> (.)
+ (:$) -> ($)
+ (:@) f x -> (.@) (trans f) (trans x)
+ Const -> const
+ Flip -> flip
+ Id -> id
+ Unit -> unit
instance Trans ValueCode Haskell where
trans = Haskell
type instance Output Haskell = ValueCode
instance Haskellable Haskell where
(.) = (:.)
($) = (:$)
- (.@) = (:@)
+ -- Small optimizations, mainly to reduce dump sizes.
+ Id .@ x = x
+ (Const :@ x) .@ _y = x
+ ((Flip :@ Const) :@ _x) .@ y = y
+ f .@ x = f :@ x
const = Const
flip = Flip
id = Id
import Control.Monad (Monad(..))
import Data.Bool (Bool(..))
import Data.Eq (Eq(..))
+import Data.Foldable (foldMap)
import Data.Function (($), (.))
import Data.Functor ((<$>))
import Data.Functor.Compose (Compose(..))
import Data.Maybe (Maybe(..), isNothing)
import Data.Monoid (Monoid(..))
import Data.Ord (Ord(..))
-import Data.Tuple (fst)
-- import GHC.Exts (Int(..))
-- import GHC.Prim (unsafeCoerce#)
import GHC.StableName (StableName(..), makeStableName, hashStableName, eqStableName)
import qualified Control.Monad.Trans.State as MT
import qualified Data.HashMap.Strict as HM
import qualified Data.HashSet as HS
-import qualified Data.List as List
import Symantic.Univariant.Trans
-- import Debug.Trace (trace)
-- * Class 'Letable'
--- | This class is not for manual usage like usual symantic operators, here 'def' and 'ref' are introduced by 'observeSharing'.
+-- | This class is not for manual usage like usual symantic operators,
+-- here 'def' and 'ref' are introduced by 'observeSharing'.
class Letable letName repr where
-- | @('def' letName x)@ let-binds @(letName)@ to be equal to @(x)@.
def :: letName -> repr a -> repr a
- -- | @('ref' isRec letName)@ is a reference to @(letName)@. @(isRec)@ is 'True' iif. this 'ref'erence is recursive, ie. is reachable within its 'def'inition.
+ -- | @('ref' isRec letName)@ is a reference to @(letName)@.
+ -- @(isRec)@ is 'True' iif. this 'ref'erence is recursive,
+ -- ie. is reachable within its 'def'inition.
ref :: Bool -> letName -> repr a
default def ::
Liftable1 repr => Letable letName (Output repr) =>
-- * Type 'SharingName'
-- | Note that the observable sharing enabled by 'StableName'
-- is not perfect as it will not observe all the sharing explicitely done.
+--
+-- Note also that the observed sharing could be different between ghc and ghci.
data SharingName = forall a. SharingName (StableName a)
-- | @('makeSharingName' x)@ is like @('makeStableName' x)@ but it also forces
-- evaluation of @(x)@ to ensure that the 'StableName' is correct first time,
-- Note that maybe [pseq should be used here](https://gitlab.haskell.org/ghc/ghc/-/issues/2916).
makeSharingName :: a -> SharingName
makeSharingName !x = SharingName $ unsafePerformIO $ makeStableName x
+
instance Eq SharingName where
SharingName x == SharingName y = eqStableName x y
instance Hashable SharingName where
, oss_recs = HS.empty
}
let refs = HS.fromList $
- (fst <$>) $
- List.filter (\(_letName, refCount) -> refCount > 0) $
+ foldMap (\(letName, refCount) -> if refCount > 0 then [letName] else []) $
HM.elems $ oss_refs st
-- trace (show refs) $
unCleanDefs a refs
newtype CleanDefs letName repr a = CleanDefs { unCleanDefs ::
HS.HashSet letName -> repr a }
-type instance Output (CleanDefs letName repr) = repr
+type instance Output (CleanDefs _letName repr) = repr
instance Trans repr (CleanDefs letName repr) where
trans = CleanDefs . pure
instance Trans1 repr (CleanDefs letName repr) where
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE Rank2Types #-}
module Golden where
import Control.Monad (Monad(..))
import Data.Semigroup (Semigroup(..))
import Data.String (String, IsString(..))
import System.IO (IO, FilePath)
+import Text.Show (Show(..))
import Test.Tasty
import Test.Tasty.Golden
import qualified Data.ByteString.Lazy as BSL
import qualified Language.Haskell.TH.Syntax as TH
import qualified Symantic.Parser as P
+import qualified Symantic.Parser.Staging as Hask
import Golden.Grammar
goldensIO :: IO TestTree
[ goldensGrammar
]
+
goldensGrammar :: TestTree
goldensGrammar = testGroup "Grammar"
[ testGroup "DumpComb" $
- let file p = "test/Golden/Grammar/"<>p<>".dump" in
- let test name repr =
- goldenVsStringDiff (file name) diffGolden (file name) $ do
- -- XXX: Resetting 'TH.counter' makes 'makeLetName' deterministic,
- -- except when profiling is enabled, in this case those tests may fail
- -- due to a different numbering of the 'def' and 'ref' combinators.
- IORef.writeIORef TH.counter 0
- return $ fromString $ P.showGrammar repr in
- [ test "unit" P.unit
+ tests $ \name repr ->
+ let file = "test/Golden/Grammar/"<>name<>".dump" in
+ goldenVsStringDiff file diffGolden file $ do
+ -- XXX: Resetting 'TH.counter' makes 'makeLetName' deterministic,
+ -- except when profiling is enabled, in this case those tests may fail
+ -- due to a different numbering of the 'def' and 'ref' combinators.
+ IORef.writeIORef TH.counter 0
+ return $ fromString $ show $ P.dumpComb $ P.observeSharing repr
+ , testGroup "OptimizeComb" $
+ tests $ \name repr ->
+ let file = "test/Golden/Grammar/"<>name<>".opt.dump" in
+ goldenVsStringDiff file diffGolden file $ do
+ IORef.writeIORef TH.counter 0
+ return $ fromString $ show $ P.dumpComb $ P.optimizeComb $ P.observeSharing repr
+ ]
+ where
+ tests :: P.Grammar repr => (forall a. String -> repr a -> TestTree) -> [TestTree]
+ tests test =
+ [ test "unit" $ P.unit
, test "unit-unit" $ P.unit P.*> P.unit
- , test "boom" boom
- , test "brainfuck" brainfuck
+ , test "app" $ P.pure (Hask.Haskell Hask.id) P.<*> P.unit
+ , test "boom" $ boom
+ , test "brainfuck" $ brainfuck
]
- ]
-- * Golden testing utilities
--- /dev/null
+<*>
++ pure Haskell
+` pure ()
--- /dev/null
+pure (Haskell ())
<*>
+ <*>
| + <*>
-| | + <*>
-| | | + pure (@) ((@) (.) ((@) (.) ((@) ((@) flip ($)) ((@) const id)))) ((@) ((@) (.) ((@) (.) (.))) ((@) ((@) (.) ((@) (.) (.))) ((@) ((@) (.) ((@) (.) ((@) const id))) ((@) const id))))
-| | | ` def let_3
-| | | ` <*>
-| | | + <*>
-| | | | + pure (@) const id
-| | | | ` def let_5
-| | | | ` <*>
-| | | | + <*>
-| | | | | + pure (@) const id
-| | | | | ` rec let_3
-| | | | ` rec let_5
-| | | ` rec let_3
-| | ` def let_2
-| | ` pure ()
-| ` def let_1
-| ` <*>
-| + <*>
-| | + pure (@) const id
-| | ` def let_4
-| | ` <*>
-| | + <*>
-| | | + pure (@) const id
-| | | ` rec let_1
-| | ` rec let_4
-| ` rec let_1
-` ref let_2
+| | + pure const
+| | ` pure id
+| ` <*>
+| + <*>
+| | + <*>
+| | | + pure const
+| | | ` pure id
+| | ` def let_3
+| | ` <*>
+| | + <*>
+| | | + <*>
+| | | | + pure const
+| | | | ` pure id
+| | | ` def let_5
+| | | ` <*>
+| | | + <*>
+| | | | + <*>
+| | | | | + pure const
+| | | | | ` pure id
+| | | | ` rec let_3
+| | | ` rec let_5
+| | ` rec let_3
+| ` def let_1
+| ` pure ()
+` <*>
+ + <*>
+ | + <*>
+ | | + pure const
+ | | ` pure id
+ | ` def let_2
+ | ` <*>
+ | + <*>
+ | | + <*>
+ | | | + pure const
+ | | | ` pure id
+ | | ` def let_4
+ | | ` <*>
+ | | + <*>
+ | | | + <*>
+ | | | | + pure const
+ | | | | ` pure id
+ | | | ` rec let_2
+ | | ` rec let_4
+ | ` rec let_2
+ ` ref let_1
--- /dev/null
+<*>
++ <*>
+| + <*>
+| | + <*>
+| | | + pure ((.) ((flip ($)) (const id)) . ((.) (.) . ((.) (.) . ((.) (const id) . const id))))
+| | | ` def let_3
+| | | ` <*>
+| | | + <*>
+| | | | + pure (const id)
+| | | | ` def let_5
+| | | | ` <*>
+| | | | + <*>
+| | | | | + pure (const id)
+| | | | | ` rec let_3
+| | | | ` rec let_5
+| | | ` rec let_3
+| | ` def let_1
+| | ` pure ()
+| ` def let_2
+| ` <*>
+| + <*>
+| | + pure (const id)
+| | ` def let_4
+| | ` <*>
+| | + <*>
+| | | + pure (const id)
+| | | ` rec let_2
+| | ` rec let_4
+| ` rec let_2
+` ref let_1
<*>
+ <*>
-| + pure (@) const id
-| ` def let_2
+| + <*>
+| | + pure const
+| | ` pure id
+| ` def let_1
| ` <*>
-| + pure (@) ((@) (.) ((@) ((@) flip ($)) ())) ((@) const id)
-| ` chainPost
-| + pure ()
-| ` <*>
-| + pure (@) ((@) ((@) (.) ((@) (.) ((@) ((@) flip ($)) id))) const) id
-| ` satisfy
-` def let_1
+| + <*>
+| | + <*>
+| | | + pure const
+| | | ` pure id
+| | ` chainPost
+| | + pure ()
+| | ` <*>
+| | + <*>
+| | | + pure flip
+| | | ` pure const
+| | ` def let_2
+| | ` satisfy
+| ` pure ()
+` def let_3
` chainPre
+ <*>
- | + conditional
- | | + bs
- | | | + <*>
- | | | | + pure (@) ((@) (.) ((@) (.) Haskell)) ((@) ((@) (.) const) ((@) const Haskell))
- | | | | ` satisfy
- | | | + <*>
- | | | | + pure (@) ((@) (.) ((@) (.) Haskell)) ((@) ((@) (.) const) ((@) const Haskell))
- | | | | ` satisfy
- | | | + <*>
- | | | | + pure (@) ((@) (.) ((@) (.) Haskell)) ((@) ((@) (.) const) ((@) const Haskell))
- | | | | ` satisfy
- | | | + <*>
- | | | | + pure (@) ((@) (.) ((@) (.) Haskell)) ((@) ((@) (.) const) ((@) const Haskell))
- | | | | ` satisfy
- | | | + <*>
- | | | | + pure (@) ((@) (.) ((@) (.) Haskell)) ((@) ((@) (.) const) ((@) const Haskell))
- | | | | ` satisfy
- | | | + <*>
- | | | | + pure (@) ((@) (.) ((@) (.) Haskell)) ((@) ((@) (.) const) ((@) const Haskell))
- | | | | ` satisfy
- | | | ` <*>
- | | | + <*>
- | | | | + <*>
- | | | | | + <*>
- | | | | | | + pure (@) ((@) (.) ((@) (.) ((@) (.) ((@) (.) ((@) (.) Haskell))))) ((@) ((@) (.) ((@) (.) ((@) (.) ((@) (.) const)))) ((@) ((@) (.) ((@) (.) ((@) (.) ((@) ((@) flip ($)) ((@) const Haskell))))) ((@) ((@) (.) ((@) (.) ((@) (.) (.)))) ((@) ((@) (.) ((@) (.) ((@) (.) const))) ((@) ((@) (.) ((@) (.) ((@) ((@) flip ($)) Haskell))) ((@) ((@) (.) ((@) (.) (.))) ((@) ((@) (.) ((@) (.) ((@) const id))) const)))))))
- | | | | | | ` satisfy
- | | | | | ` ref let_2
- | | | | ` rec let_1
- | | | ` satisfy
- | | + look
- | | | ` satisfy
- | | ` empty
- | ` ref let_2
+ | + pure Haskell
+ | ` <*>
+ | + <*>
+ | | + pure const
+ | | ` conditional
+ | | + bs
+ | | | + <*>
+ | | | | + <*>
+ | | | | | + pure const
+ | | | | | ` pure Haskell
+ | | | | ` ref let_2
+ | | | + <*>
+ | | | | + <*>
+ | | | | | + pure const
+ | | | | | ` pure Haskell
+ | | | | ` ref let_2
+ | | | + <*>
+ | | | | + <*>
+ | | | | | + pure const
+ | | | | | ` pure Haskell
+ | | | | ` ref let_2
+ | | | + <*>
+ | | | | + <*>
+ | | | | | + pure const
+ | | | | | ` pure Haskell
+ | | | | ` ref let_2
+ | | | + <*>
+ | | | | + <*>
+ | | | | | + pure const
+ | | | | | ` pure Haskell
+ | | | | ` ref let_2
+ | | | + <*>
+ | | | | + <*>
+ | | | | | + pure const
+ | | | | | ` pure Haskell
+ | | | | ` ref let_2
+ | | | ` <*>
+ | | | + <*>
+ | | | | + pure const
+ | | | | ` <*>
+ | | | | + <*>
+ | | | | | + <*>
+ | | | | | | + pure const
+ | | | | | | ` pure id
+ | | | | | ` <*>
+ | | | | | + <*>
+ | | | | | | + pure const
+ | | | | | | ` ref let_2
+ | | | | | ` ref let_1
+ | | | | ` <*>
+ | | | | + pure Haskell
+ | | | | ` rec let_3
+ | | | ` <*>
+ | | | + <*>
+ | | | | + pure const
+ | | | | ` pure Haskell
+ | | | ` ref let_2
+ | | + look
+ | | | ` ref let_2
+ | | ` empty
+ | ` ref let_1
` pure Haskell
--- /dev/null
+<*>
++ <*>
+| + pure (const id)
+| ` def let_1
+| ` <*>
+| + pure ((flip ($)) () . const id)
+| ` chainPost
+| + pure ()
+| ` <*>
+| + pure (((.) ((flip ($)) id) . const) id)
+| ` satisfy
+` def let_2
+ ` chainPre
+ + <*>
+ | + conditional
+ | | + bs
+ | | | + <*>
+ | | | | + pure ((.) Haskell . (const . const Haskell))
+ | | | | ` satisfy
+ | | | + <*>
+ | | | | + pure ((.) Haskell . (const . const Haskell))
+ | | | | ` satisfy
+ | | | + <*>
+ | | | | + pure ((.) Haskell . (const . const Haskell))
+ | | | | ` satisfy
+ | | | + <*>
+ | | | | + pure ((.) Haskell . (const . const Haskell))
+ | | | | ` satisfy
+ | | | + <*>
+ | | | | + pure ((.) Haskell . (const . const Haskell))
+ | | | | ` satisfy
+ | | | + <*>
+ | | | | + pure ((.) Haskell . (const . const Haskell))
+ | | | | ` satisfy
+ | | | ` <*>
+ | | | + <*>
+ | | | | + <*>
+ | | | | | + <*>
+ | | | | | | + pure ((.) ((.) ((.) ((.) Haskell))) . ((.) ((.) ((.) const)) . ((.) ((.) ((flip ($)) (const Haskell))) . ((.) ((.) (.)) . ((.) ((.) const) . ((.) ((flip ($)) Haskell) . ((.) (.) . ((.) (const id) . const))))))))
+ | | | | | | ` satisfy
+ | | | | | ` ref let_1
+ | | | | ` rec let_2
+ | | | ` satisfy
+ | | + look
+ | | | ` satisfy
+ | | ` empty
+ | ` ref let_1
+ ` pure Haskell
<*>
+ <*>
-| + pure (@) const id
+| + <*>
+| | + pure const
+| | ` pure id
| ` def let_1
| ` pure ()
` ref let_1
--- /dev/null
+<*>
++ <*>
+| + pure (const id)
+| ` def let_1
+| ` pure ()
+` ref let_1
sourcephile / git / haskell / symantic-parser.git / commitdiff