From 8df0f5a1c5275b9b690075e412cf23eb70f3e188 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 19:38:38 +0800
Subject: [PATCH 01/16] parser

---
 include/hspp.h     | 780 +++++++++++++++++++++++++++++++++++----------
 test/hspp/test.cpp | 384 +++++++++++++++++-----
 2 files changed, 908 insertions(+), 256 deletions(-)

diff --git a/include/hspp.h b/include/hspp.h
index e21e6ec..6fe04a0 100644
--- a/include/hspp.h
+++ b/include/hspp.h
@@ -230,6 +230,12 @@ class CallViaPipe
     }
 };
 
+template <typename Arg, typename F>
+constexpr auto operator&(Arg&& arg, CallViaPipe<F> const& func)
+{
+    return func | arg;
+}
+
 template <typename Repr, typename Ret, typename Arg, typename... Rest>
 class Function : public CallViaPipe<Function<Repr, Ret, Arg, Rest...>>
 {
@@ -265,7 +271,7 @@ template <typename T>
 constexpr static auto isFunctionV = IsFunction<std::decay_t<T>>::value;
 
 template <typename...Args, typename Func>
-constexpr auto toFunc(Func const& func)
+constexpr auto toFuncImpl(Func const& func)
 {
     if constexpr(sizeof...(Args) == 0)
     {
@@ -278,13 +284,13 @@ constexpr auto toFunc(Func const& func)
 }
 
 template <typename Func>
-constexpr auto toTEFunc(Func const& func)
+constexpr auto toTEFuncImpl(Func const& func)
 {
     return ToFunction<true, decltype(&Func::operator())>::run(func);
 }
 
 template <typename Ret, typename... Args, typename Func>
-constexpr auto toTEFunc(Func const& func)
+constexpr auto toTEFuncImpl(Func const& func)
 {
     return TEFunction<Ret, Args...>{func};
 }
@@ -316,11 +322,29 @@ class GenericFunction : public CallViaPipe<GenericFunction<nbArgs, Repr>>
 };
 
 template <size_t nbArgs, typename Func>
-constexpr auto toGFunc(Func const& func)
+constexpr auto toGFuncImpl(Func const& func)
 {
     return GenericFunction<nbArgs, Func>{func};
 }
 
+template <size_t nbArgs>
+constexpr inline auto toGFunc = toGFuncImpl<1>([](auto data)
+{
+    return toGFuncImpl<nbArgs>(std::move(data));
+});
+
+template <typename...Args>
+constexpr inline auto toFunc = toGFunc<1>([](auto func)
+{
+    return toFuncImpl<Args...>(std::move(func));
+});
+
+template <typename...Args>
+constexpr inline auto toTEFunc = toGFunc<1>([](auto func)
+{
+    return toTEFuncImpl<Args...>(std::move(func));
+});
+
 constexpr inline auto id = toGFunc<1>([](auto data)
 {
     return data;
@@ -374,7 +398,14 @@ class Compose
     template <typename Func, typename Repr, typename Ret, typename FirstArg, typename... Args>
     constexpr auto operator()(Func&& f, Function<Repr, Ret, FirstArg, Args...> const& g) const
     {
-        return toFunc([=](FirstArg x){ return f(g(x));});
+        return toFunc<> | [=](FirstArg x){ return f(g(x));};
+    }
+    template <typename F, size_t I, typename Repr>
+    constexpr auto operator()(F&& f, GenericFunction<I, Repr> const& g) const
+    {
+        // return toGFunc<I>([=](auto&&... args){ return f((g | ... | args));});
+        // static_assert(I==1);
+        return toGFunc<1>([=](auto x){ return f(g(x));});
     }
     template <typename F, typename G>
     constexpr auto operator()(F&& f, G&&g) const
@@ -419,7 +450,7 @@ auto ioData(Data data)
     return io([data=std::move(data)] { return data; });
 }
 
-constexpr auto putStrLn = toFunc([](std::string str)
+constexpr auto putStrLn = toFunc<> | [](std::string str)
 {
     return io(
         [str=std::move(str)]
@@ -428,7 +459,7 @@ constexpr auto putStrLn = toFunc([](std::string str)
             return _o_;
         }
     );
-});
+};
 
 const inline auto getLine = io([]
     {
@@ -1301,12 +1332,12 @@ namespace impl
     template <typename Repr, typename Ret, typename Arg1, typename Arg2, typename... Rest>
     constexpr auto flipImpl(Function<Repr, Ret, Arg1, Arg2, Rest...> f)
     {
-        return toFunc([f=std::move(f)](Arg1 x, Arg2 y){ return f | y | x; });
+        return toFunc<>([f=std::move(f)](Arg1 x, Arg2 y){ return f | y | x; });
     }
     template <typename Repr1, typename Repr2, typename Ret, typename Arg1, typename Arg2, typename... Rest>
     constexpr auto flipImpl(Function<Repr1, Function<Repr2, Ret, Arg2, Rest...>, Arg1> f)
     {
-        return toFunc([f=std::move(f)](Arg2 x, Arg1 y){ return f | y | x; });
+        return toFunc<>([f=std::move(f)](Arg2 x, Arg1 y){ return f | y | x; });
     }
 } // namespace impl
 
@@ -1360,12 +1391,6 @@ constexpr auto foldl = toGFunc<3>([](auto func, auto init, auto const& list)
 
 constexpr auto equalTo = toGFunc<2>(std::equal_to<>{});
 
-// constexpr inline auto elem = any <o> equalTo;
-constexpr inline auto elem = toGFunc<2>([](auto t, auto const& c)
-{
-    return std::any_of(c.begin(), c.end(), [t=std::move(t)](auto const& e){return e == t;});
-});
-
 template <typename Repr1, typename Ret1, typename Arg1, typename... Rest1, typename Repr2, typename Ret2, typename Arg2, typename... Rest2>
 constexpr auto onImpl(Function<Repr1, Ret1, Arg1, Rest1...> f, Function<Repr2, Ret2, Arg2, Rest2...> g)
 {
@@ -1423,12 +1448,6 @@ constexpr inline auto enumFrom = toGFunc<1>([](auto start)
     return ownedRange(IotaView{start});
 });
 
-constexpr inline auto length = toGFunc<1>([](auto r)
-{
-    constexpr auto inc = toGFunc<2>([](auto sum, auto){ return sum + 1; });
-    return foldl | inc | 0 | r;
-});
-
 constexpr inline auto take = toGFunc<2>([](auto r, size_t num)
 {
     return ownedRange(TakeView{r, num});
@@ -1468,6 +1487,112 @@ constexpr inline auto makeTuple = toGFunc<N>([](auto e, auto... l)
     return std::make_tuple(std::move(e), std::move(l)...);
 });
 
+template <typename Data>
+class DataHolder
+{
+    Data mData;
+public:
+    constexpr DataHolder(Data data)
+    : mData{std::move(data)}
+    {}
+    auto const& get() const
+    {
+        return mData;
+    }
+};
+
+template <typename T>
+constexpr auto operator==(DataHolder<T> const& l, DataHolder<T> const& r)
+{
+    return l.get() == r.get();
+}
+
+template <template <typename...> typename Type>
+constexpr auto toType = toGFunc<1>([](auto data)
+{
+    return Type<decltype(data)>{data};
+});
+
+constexpr auto from = toGFunc<1>([](auto data)
+{
+    return data.get();
+});
+
+template <typename R, typename A, typename Repr>
+class Reader : public DataHolder<Function<Repr, A, R>>
+{
+public:
+    using DataHolder<Function<Repr, A, R>>::DataHolder;
+};
+
+template <typename R, typename A, typename Repr>
+constexpr auto toReaderImpl(Function<Repr, A, R> func)
+{
+    return Reader<R, A, Repr>{std::move(func)};
+}
+
+constexpr auto toReader = toGFunc<1>([](auto func)
+{
+    return toReaderImpl(std::move(func));
+});
+
+constexpr auto runReader = from;
+
+
+template <typename S, typename A, typename Repr>
+class State : public DataHolder<Function<Repr, std::tuple<A, S>, S>>
+{
+public:
+    using DataHolder<Function<Repr, std::tuple<A, S>, S>>::DataHolder;
+};
+
+template <typename S, typename A, typename Repr>
+constexpr auto toStateImpl(Function<Repr, std::tuple<A, S>, S> func)
+{
+    return State<S, A, Repr>{std::move(func)};
+}
+
+constexpr auto toState = toGFunc<1>([](auto func)
+{
+    return toStateImpl(std::move(func));
+});
+
+constexpr auto runState = from;
+
+template <typename A, typename Repr>
+class Parser : public DataHolder<Function<Repr, std::vector<std::tuple<A, std::string>>, std::string>>
+{
+public:
+    using DataHolder<Function<Repr, std::vector<std::tuple<A, std::string>>, std::string>>::DataHolder;
+};
+
+template <typename A, typename Repr>
+constexpr auto toParserImpl(Function<Repr, std::vector<std::tuple<A, std::string>>, std::string> func)
+{
+    return Parser<A, Repr>{std::move(func)};
+}
+
+constexpr auto toParser = toGFunc<1>([](auto func)
+{
+    return toParserImpl(std::move(func));
+});
+
+constexpr auto runParser = from;
+
+template <typename A>
+using TEParser = Parser<A, std::function<std::vector<std::tuple<A, std::string>>(std::string)>>;
+
+template <typename A, typename Repr>
+constexpr auto toTEParserImpl(Parser<A, Repr> p)
+{
+    return TEParser<A>{(runParser | p)};
+};
+
+constexpr auto toTEParser = toGFunc<1> | [](auto p)
+{
+    return toTEParserImpl(p);
+};
+
 } // namespace data
 
 using data::o;
@@ -1480,6 +1605,24 @@ using data::toGFunc;
 using data::unCurry;
 using data::id;
 
+/////////////// Data Trait //////////////////
+template <typename T>
+struct DataTrait;
+
+template <template <typename...> class Class, typename Data, typename... Rest>
+struct DataTrait<Class<Data, Rest...>>
+{
+    using Type = Data;
+    template <typename DataT>
+    using ReplaceDataTypeWith = Class<DataT>;
+};
+
+template <typename T>
+using DataType = typename DataTrait<std::decay_t<T>>::Type;
+
+template <typename T, typename Data>
+using ReplaceDataTypeWith = typename DataTrait<std::decay_t<T>>::template ReplaceDataTypeWith<Data>;
+
 /////////////// TypeClass Traits //////////////////
 
 template <template <template<typename...> typename Type, typename... Ts> class TypeClassT,  typename T>
@@ -1497,6 +1640,12 @@ struct TypeClassTrait<TypeClassT, data::Function<Repr, Ret, Arg, Rest...>>
     using Type = TypeClassT<data::Function, Arg>;
 };
 
+template <template <template<typename...> typename Type, typename... Ts> class TypeClassT, typename A, typename Repr>
+struct TypeClassTrait<TypeClassT, data::Parser<A, Repr>>
+{
+    using Type = TypeClassT<data::Parser>;
+};
+
 template <typename>
 class DummyTemplateClass{};
 
@@ -1589,6 +1738,38 @@ class FoldMap
 
 constexpr inline auto foldMap = toGFunc<2>(FoldMap{});
 
+////////// Traversable ////////////
+
+template <template<typename...> typename Type, typename... Args>
+class Traversable;
+
+template <typename T>
+using TraversableType = typename TypeClassTrait<Traversable, std::decay_t<T>>::Type;
+
+class Traverse
+{
+public:
+    template <typename Func, template <typename...> class T, typename MData, typename... Rest, typename TType = TraversableType<T<MData, Rest...>>>
+    constexpr auto operator()(Func&& f, T<MData, Rest...> const& data) const
+    {
+        return TType::traverse | f | data;
+    }
+};
+
+constexpr inline auto traverse = toGFunc<2>(Traverse{});
+
+class SequenceA
+{
+public:
+    template <template <typename...> class T, typename MData, typename... Rest, typename TType = TraversableType<T<MData, Rest...>>>
+    constexpr auto operator()(T<MData, Rest...> const& data) const
+    {
+        return TType::sequenceA | data;
+    }
+};
+
+constexpr inline auto sequenceA = toGFunc<1>(SequenceA{});
+
 /////////////// Monoid Traits ///////////////
 
 template <template<typename...> typename Type, typename... Args>
@@ -1650,7 +1831,7 @@ class MonoidBaseImpl
 public:
     const static Type<Args...> mempty;
 
-    constexpr static auto mappend = data::toFunc([](Type<Args...> const& lhs, Type<Args...> const& rhs)
+    constexpr static auto mappend = data::toFunc<>([](Type<Args...> const& lhs, Type<Args...> const& rhs)
     {
         auto const r = data::ChainView{data::RefView{lhs}, data::RefView{rhs}};
         Type<Args...> result;
@@ -1674,77 +1855,46 @@ class MonoidBase<std::list, Args...> : public MonoidBaseImpl<std::list, Args...>
 template <typename... Args>
 class MonoidBase<std::basic_string, Args...> : public MonoidBaseImpl<std::basic_string, Args...>{};
 
-template <typename Data>                                        
-class DataHolder                                                 
-{
-    Data mData;                                                 
-public:
-    constexpr DataHolder(Data data)                              
-    : mData{std::move(data)}                                               
-    {}                                                          
-    auto const& get() const                                            
-    {                                                           
-        return mData;                                           
-    }                                                           
-};                                                              
-                                                                
-template <typename T>                                           
-constexpr auto operator==(DataHolder<T> const& l, DataHolder<T> const& r)       
-{                                                               
-    return l.get() == r.get();                                  
-}                                                               
-
-template <template <typename...> typename Type>
-constexpr auto toType = toGFunc<1>([](auto data)             
-{                                                               
-    return Type<decltype(data)>{data};                                     
-});                                                             
-                                                                
-constexpr auto from = toGFunc<1>([](auto data)          
-{                                                               
-    return data.get();                                          
-});
-
 template <typename Data>
-class Product : public DataHolder<Data>
+class Product : public data::DataHolder<Data>
 {
 public:
-    using DataHolder<Data>::DataHolder;
+    using data::DataHolder<Data>::DataHolder;
 };
 
 template <typename Data>
-class Sum : public DataHolder<Data>
+class Sum : public data::DataHolder<Data>
 {
 public:
-    using DataHolder<Data>::DataHolder;
+    using data::DataHolder<Data>::DataHolder;
 };
 
 template <typename Data>
-class AllImpl : public DataHolder<Data>
+class AllImpl : public data::DataHolder<Data>
 {
 public:
-    using DataHolder<Data>::DataHolder;
+    using data::DataHolder<Data>::DataHolder;
 };
 
 template <typename Data>
-class AnyImpl : public DataHolder<Data>
+class AnyImpl : public data::DataHolder<Data>
 {
 public:
-    using DataHolder<Data>::DataHolder;
+    using data::DataHolder<Data>::DataHolder;
 };
 
 template <typename Data>
-class First : public DataHolder<data::Maybe<Data>>
+class First : public data::DataHolder<data::Maybe<Data>>
 {
 public:
-    using DataHolder<data::Maybe<Data>>::DataHolder;
+    using data::DataHolder<data::Maybe<Data>>::DataHolder;
 };
 
 template <typename Data>
-class Last : public DataHolder<data::Maybe<Data>>
+class Last : public data::DataHolder<data::Maybe<Data>>
 {
 public:
-    using DataHolder<data::Maybe<Data>>::DataHolder;
+    using data::DataHolder<data::Maybe<Data>>::DataHolder;
 };
 
 template <typename Data>
@@ -1820,40 +1970,40 @@ class ZipList
 };
 
 template <typename Func>
-class Endo : public DataHolder<Func>
+class Endo : public data::DataHolder<Func>
 {
 public:
-    using DataHolder<Func>::DataHolder;
+    using data::DataHolder<Func>::DataHolder;
 };
 
-constexpr auto product = toType<Product>;
-constexpr auto sum = toType<Sum>;
-constexpr auto all = toType<AllImpl>;
-constexpr auto any = toType<AnyImpl>;
-constexpr auto first = toGFunc<1>([](auto data)             
-{                                                               
+constexpr auto toProduct = data::toType<Product>;
+constexpr auto toSum = data::toType<Sum>;
+constexpr auto toAll = data::toType<AllImpl>;
+constexpr auto toAny = data::toType<AnyImpl>;
+constexpr auto toFirst = toGFunc<1>([](auto data)
+{
     using Type = std::decay_t<decltype(data.value())>;
-    return First<Type>{data};                                     
-});                                                             
-constexpr auto last = toGFunc<1>([](auto data)
+    return First<Type>{data};
+});
+constexpr auto toLast = toGFunc<1>([](auto data)
 {
     using Type = std::decay_t<decltype(data.value())>;
-    return Last<Type>{data};                                     
+    return Last<Type>{data};
 });
-constexpr auto zipList = toGFunc<1>([](auto data)
+constexpr auto toZipList = toGFunc<1>([](auto data)
 {
-    return ZipList{data};                                     
+    return ZipList{data};
 });
-constexpr auto endo = toType<Endo>;
+constexpr auto toEndo = data::toType<Endo>;
 
-constexpr auto getProduct = from;
-constexpr auto getSum = from;
-constexpr auto getAll = from;
-constexpr auto getAny = from;
-constexpr auto getFirst = from;
-constexpr auto getLast = from;
-constexpr auto getZipList = from;
-constexpr auto appEndo = from;
+constexpr auto getProduct = data::from;
+constexpr auto getSum = data::from;
+constexpr auto getAll = data::from;
+constexpr auto getAny = data::from;
+constexpr auto getFirst = data::from;
+constexpr auto getLast = data::from;
+constexpr auto getZipList = data::from;
+constexpr auto appEndo = data::from;
 
 using All = AllImpl<bool>;
 using Any = AnyImpl<bool>;
@@ -1864,7 +2014,7 @@ class MonoidBase<Product, Data>
 public:
     constexpr static auto mempty = Product<Data>{1};
 
-    constexpr static auto mappend = data::toFunc([](Product<Data> const& lhs, Product<Data> const& rhs)
+    constexpr static auto mappend = data::toFunc<>([](Product<Data> const& lhs, Product<Data> const& rhs)
     {
         return Product<Data>{lhs.get() * rhs.get()};
     });
@@ -1876,7 +2026,7 @@ class MonoidBase<Sum, Data>
 public:
     constexpr static auto mempty = Sum<Data>{0};
 
-    constexpr static auto mappend = data::toFunc([](Sum<Data> const& lhs, Sum<Data> const& rhs)
+    constexpr static auto mappend = data::toFunc<>([](Sum<Data> const& lhs, Sum<Data> const& rhs)
     {
         return Sum<Data>{lhs.get() + rhs.get()};
     });
@@ -1888,7 +2038,7 @@ class MonoidBase<DummyTemplateClass, Any>
 public:
     constexpr static auto mempty = Any{false};
 
-    constexpr static auto mappend = data::toFunc([](Any lhs, Any rhs)
+    constexpr static auto mappend = data::toFunc<>([](Any lhs, Any rhs)
     {
         return Any{lhs.get() || rhs.get()};
     });
@@ -1900,7 +2050,7 @@ class MonoidBase<DummyTemplateClass, All>
 public:
     constexpr static auto mempty = All{true};
 
-    constexpr static auto mappend = data::toFunc([](All lhs, All rhs)
+    constexpr static auto mappend = data::toFunc<>([](All lhs, All rhs)
     {
         return All{lhs.get() && rhs.get()};
     });
@@ -1912,7 +2062,7 @@ class MonoidBase<First, Data>
 public:
     constexpr static auto mempty = First<Data>{data::nothing};
 
-    constexpr static auto mappend = data::toFunc([](First<Data> lhs, First<Data> rhs)
+    constexpr static auto mappend = data::toFunc<>([](First<Data> lhs, First<Data> rhs)
     {
         return (getFirst | lhs) == data::nothing ? rhs : lhs;
     });
@@ -1924,7 +2074,7 @@ class MonoidBase<Last, Data>
 public:
     constexpr static auto mempty = Last<Data>{data::nothing};
 
-    constexpr static auto mappend = data::toFunc([](Last<Data> lhs, Last<Data> rhs)
+    constexpr static auto mappend = data::toFunc<>([](Last<Data> lhs, Last<Data> rhs)
     {
         return (getLast | rhs) == data::nothing ? lhs : rhs;
     });
@@ -1939,7 +2089,7 @@ class MonoidBase<ZipList, Data>
 
     constexpr static auto mappend = toGFunc<2>([](auto lhs, auto rhs)
     {
-        return zipList <o> data::to<std::list> || data::zipWith | DataMType::mappend | data::nonOwnedRange(lhs) | data::nonOwnedRange(rhs);
+        return toZipList <o> data::to<std::list> || data::zipWith | DataMType::mappend | data::nonOwnedRange(lhs) | data::nonOwnedRange(rhs);
     });
 };
 
@@ -1950,11 +2100,11 @@ template <>
 class MonoidBase<Endo>
 {
 public:
-    constexpr static auto mempty = endo | id;
+    constexpr static auto mempty = toEndo | id;
 
     constexpr static auto mappend = data::toGFunc<2>([](auto&& lhs, auto&& rhs)
     {
-        return endo || lhs.get() <o> rhs.get();
+        return toEndo || lhs.get() <o> rhs.get();
     });
 };
 
@@ -1984,7 +2134,7 @@ class MonoidBase<DummyTemplateClass, Ordering>
 public:
     constexpr static auto mempty = Ordering::kEQ;
 
-    constexpr static auto mappend = data::toFunc([](Ordering lhs, Ordering rhs)
+    constexpr static auto mappend = data::toFunc<>([](Ordering lhs, Ordering rhs)
     {
         switch (lhs)
         {
@@ -2005,7 +2155,7 @@ class MonoidBase<DummyTemplateClass, _O_>
 public:
     constexpr static auto mempty = _o_;
 
-    constexpr static auto mappend = data::toFunc([](_O_, _O_)
+    constexpr static auto mappend = data::toFunc<>([](_O_, _O_)
     {
         return _o_;
     });
@@ -2068,14 +2218,14 @@ template <typename InArg, typename RetType>
 class MonoidBase<data::Function, InArg, RetType>
 {
 public:
-    constexpr static auto mempty = data::toFunc([](InArg)
+    constexpr static auto mempty = data::toFunc<>([](InArg)
     {
         return MonoidType<RetType>::mempty;
     });
 
     constexpr static auto mappend = toGFunc<2>([](auto f, auto g)
     {
-        return data::toFunc([f=std::move(f), g=std::move(g)](InArg arg)
+        return data::toFunc<>([f=std::move(f), g=std::move(g)](InArg arg)
         {
             using MType = MonoidType<RetType>;
             return (f | arg) <MType::mappend> (g | arg);
@@ -2106,7 +2256,7 @@ class MonoidBase<std::tuple, Ts...>
 public:
     const static decltype(std::make_tuple(MonoidType<Ts>::mempty...)) mempty;
 
-    constexpr static auto mappend = data::toFunc([](std::tuple<Ts...> lhs, std::tuple<Ts...> rhs)
+    constexpr static auto mappend = data::toFunc<>([](std::tuple<Ts...> lhs, std::tuple<Ts...> rhs)
     {
         constexpr auto mapp = toGFunc<2>(Mappend{});
         return zipTupleWith(mapp, lhs, rhs);
@@ -2122,7 +2272,7 @@ class MonoidBase<data::Maybe, Data>
 public:
     const static data::Maybe<Data> mempty;
 
-    constexpr static auto mappend = data::toFunc([](data::Maybe<Data> const& lhs, data::Maybe<Data> const& rhs)
+    constexpr static auto mappend = data::toFunc<>([](data::Maybe<Data> const& lhs, data::Maybe<Data> const& rhs)
     {
         return std::visit(overload(
             [](data::Just<Data> const& l, data::Just<Data> const& r) -> data::Maybe<Data>
@@ -2240,7 +2390,7 @@ class FoldableBase
 public:
     constexpr static auto foldr = toGFunc<3>([](auto&& f, auto&& z, auto&& t)
     {
-        return appEndo || hspp::foldMap | (endo <o> f) | t || z;
+        return appEndo || hspp::foldMap | (toEndo <o> f) | t || z;
     });
     constexpr static auto foldMap = toGFunc<2>([](auto&& func, auto&& ta)
     {
@@ -2249,11 +2399,11 @@ class FoldableBase
         return hspp::foldr | (mappend <o> func) | MonoidType<MData>::mempty | ta;
     });
     constexpr static auto fold = hspp::foldMap | id;
-    constexpr static auto toRange = toGFunc<1>([](auto&& tm)
+    constexpr static auto toRange = toGFunc<1>([](auto const& tm)
     {
         return nonOwnedRange(data::RefView{tm});
     });
-    constexpr static auto null = hspp::foldr | [](auto, auto){ return false; } | true;
+    constexpr static auto null = hspp::foldr | [](auto, bool){ return false; } | true;
 };
 
 template <template<typename...> typename Type, typename... Args>
@@ -2273,7 +2423,7 @@ class Foldable<std::tuple, Init...> : public FoldableBase<std::tuple, Init...>
         auto const& last = std::get<sizeof...(Init)>(ta);
         return func | last;
     });
-    constexpr static auto foldr = toGFunc<1>([](auto&& func, auto&& z, auto&& ta)
+    constexpr static auto foldr = toGFunc<3>([](auto&& func, auto&& z, auto&& ta)
     {
         static_assert(std::tuple_size_v<std::decay_t<decltype(ta)>> == sizeof...(Init)+1);
         auto const& last = std::get<sizeof...(Init)>(ta);
@@ -2281,6 +2431,26 @@ class Foldable<std::tuple, Init...> : public FoldableBase<std::tuple, Init...>
     });
 };
 
+template <>
+class FoldableBase<data::Maybe>
+{
+public:
+    constexpr static auto foldr = toGFunc<3>([](auto&& func, auto&& z, auto&& ta)
+    {
+        if (ta == data::nothing)
+        {
+            return z;
+        }
+        return func | ta.value() | z;
+    });
+    constexpr static auto foldMap = toGFunc<2>([](auto&& func, auto&& ta)
+    {
+        using Data = decltype(ta.value());
+        using MData = std::invoke_result_t<decltype(func), Data>;
+        return foldr | (mappend <o> func) | MonoidType<MData>::mempty | ta;
+    });
+};
+
 /////////// Functor ///////////
 
 template <template<typename...> typename Type, typename... Ts>
@@ -2353,6 +2523,17 @@ class Functor<data::Function, FirstArg>
     }
 };
 
+template <typename FirstArg>
+class Functor<data::Reader, FirstArg>
+{
+public:
+    template <typename Func, typename Repr, typename Ret, typename... Args>
+    constexpr static auto fmap(Func&& func, data::Reader<FirstArg, Ret, Repr> const& in)
+    {
+        return data::toReader | func <o> (data::runReader | in);
+    }
+};
+
 template <>
 class Functor<DummyTemplateClass, GenericFunctionTag>
 {
@@ -2379,11 +2560,10 @@ template <template<typename...> class Type, typename... Ts>
 class Applicative : public Functor<Type, Ts...>
 {
 public:
-    template <typename In>
-    constexpr static auto pure(In in)
+    constexpr static auto pure = toGFunc<1> | [](auto in)
     {
-        return Type<std::decay_t<In>>{in};
-    }
+        return Type<std::decay_t<decltype(in)>>{in};
+    };
     template <typename Func, typename Arg>
     constexpr static auto ap(Type<Func> const& func, Type<Arg> const& in)
     {
@@ -2404,11 +2584,10 @@ template <>
 class Applicative<data::Range> : public Functor<data::Range>
 {
 public:
-    template <typename In>
-    constexpr static auto pure(In&& in)
+    constexpr static auto pure = toGFunc<1> | [](auto&& in)
     {
-        return data::ownedRange(data::SingleView{std::forward<In>(in)});
-    }
+        return data::ownedRange(data::SingleView{std::forward<decltype(in)>(in)});
+    };
     template <typename Func, typename Arg, typename Repr1, typename Repr2>
     constexpr static auto ap(data::Range<Func, Repr1> const& func, data::Range<Arg, Repr2> const& in)
     {
@@ -2421,11 +2600,10 @@ template <typename... Init>
 class Applicative<std::tuple, Init...> : public Functor<std::tuple, Init...>
 {
 public:
-    template <typename Last>
-    constexpr static auto pure(Last in)
+    constexpr static auto pure = toGFunc<1> | [](auto in)
     {
         return std::make_tuple(MonoidType<Init>::mempty..., std::move(in));
-    }
+    };
     template <typename Func, typename Last>
     constexpr static auto ap(std::tuple<Init..., Func> const& funcs, std::tuple<Init..., Last> const& args)
     {
@@ -2466,11 +2644,10 @@ template <>
 class Applicative<data::IO> : public Functor<data::IO>
 {
 public:
-    template <typename In>
-    constexpr static auto pure(In in)
+    constexpr static auto pure = toGFunc<1> | [](auto in)
     {
         return data::ioData(std::move(in));
-    }
+    };
     template <typename Func, typename Arg, typename Func1, typename Func2>
     constexpr static auto ap(data::IO<Func, Func1> const& func, data::IO<Arg, Func2> const& in)
     {
@@ -2482,15 +2659,14 @@ template <typename FirstArg>
 class Applicative<data::Function, FirstArg> : public Functor<data::Function, FirstArg>
 {
 public:
-    template <typename Ret>
-    constexpr static auto pure(Ret ret)
+    constexpr static auto pure = toGFunc<1> | [](auto ret)
     {
-        return data::toFunc([ret=std::move(ret)](FirstArg){ return ret; });
-    }
+        return data::toFunc<>([ret=std::move(ret)](FirstArg){ return ret; });
+    };
     template <typename Func1, typename Func2>
     constexpr static auto ap(Func1 func, Func2 in)
     {
-        return data::toFunc(
+        return data::toFunc<>(
             [func=std::move(func), in=std::move(in)](FirstArg arg)
             {
                 return func(arg)(in(arg));
@@ -2498,15 +2674,62 @@ class Applicative<data::Function, FirstArg> : public Functor<data::Function, Fir
     }
 };
 
+template <typename FirstArg>
+class Applicative<data::Reader, FirstArg> : public Functor<data::Reader, FirstArg>
+{
+public:
+    constexpr static auto pure = toGFunc<1> | [](auto ret)
+    {
+        return data::toReader | data::toFunc<>([ret=std::move(ret)](FirstArg){ return ret; });
+    };
+    template <typename Reader1, typename Reader2>
+    constexpr static auto ap(Reader1 func, Reader1 in)
+    {
+        return data::toReader | data::toFunc<>(
+            [func=std::move(func), in=std::move(in)](FirstArg arg)
+            {
+                return data::runReader | func | arg || data::runReader | in | arg;
+            });
+    }
+};
+
+template <typename S>
+class Applicative<data::State, S> : public Functor<data::State, S>
+{
+public:
+    constexpr static auto pure = toGFunc<1> | [](auto ret)
+    {
+        return data::toState | data::toFunc<>([ret=std::move(ret)](S st){ return std::make_tuple(ret, st); });
+    };
+    // template <typename Func, typename State>
+    // constexpr static auto ap(Func func, State in)
+    // {
+    //     return data::toState | data::toFunc<>(
+    //         [func=std::move(func), in=std::move(in)](FirstArg arg)
+    //         {
+    //             return data::runReader | func | arg || data::runReader | in | arg;
+    //         });
+    // }
+};
+
+template <>
+class Applicative<data::Parser> : public Functor<data::Parser>
+{
+public:
+    constexpr static auto pure = toGFunc<1> | [](auto a)
+    {
+        return data::toParser || data::toFunc<> | [a=std::move(a)](std::string cs){ return std::vector{std::make_tuple(a, cs)}; };
+    };
+};
+
 template <>
 class Applicative<DummyTemplateClass, GenericFunctionTag> : public Functor<DummyTemplateClass, GenericFunctionTag>
 {
 public:
-    template <typename Ret>
-    constexpr static auto pure(Ret ret)
+    constexpr static auto pure = toGFunc<1> | [](auto ret)
     {
         return toGFunc<1>([=](auto){ return ret; });
-    }
+    };
     template <typename Func1, typename Func2>
     constexpr static auto ap(Func1 func, Func2 in)
     {
@@ -2538,14 +2761,19 @@ constexpr auto pure = toGFunc<1>([](auto const& data)
 
 constexpr auto return_ = pure;
 
+class DeferredGuard;
+
 template <typename T>
-class IsDeferredPure : public std::false_type
+class IsDeferred : public std::false_type
 {};
 template <typename T>
-class IsDeferredPure<DeferredPure<T>> : public std::true_type
+class IsDeferred<DeferredPure<T>> : public std::true_type
+{};
+template <>
+class IsDeferred<DeferredGuard> : public std::true_type
 {};
 template <typename T>
-constexpr static auto isDeferredPureV = IsDeferredPure<T>::value;
+constexpr static auto isDeferredV = IsDeferred<std::decay_t<T>>::value;
 
 class Ap
 {
@@ -2593,11 +2821,7 @@ template <template<typename...> class Type, typename... Ts>
 class Monad : public Applicative<Type, Ts...>, public MonadBase<Type, Ts...>, public MonadRShift<MonadBase<Type, Ts...>>
 {
 public:
-    template <typename Arg>
-    constexpr static auto return_(Arg arg)
-    {
-        return Applicative<Type, Ts...>::pure(arg);
-    }
+    constexpr static auto return_ = Applicative<Type, Ts...>::pure;
 };
 
 template <template<typename...> class Type, typename... Ts>
@@ -2680,21 +2904,74 @@ class MonadBase<data::Function, FirstArg>
     }
 };
 
+template <typename FirstArg>
+class MonadBase<data::Reader, FirstArg>
+{
+public:
+    template <typename Ret, typename Repr, typename Func>
+    constexpr static auto bind(data::Reader<FirstArg, Ret, Repr> const& m, Func k)
+    {
+        return (flip | std::move(k)) <ap> m;
+    }
+};
+
+template <typename S>
+class MonadBase<data::State, S>
+{
+public:
+    template <typename A, typename Repr, typename Func>
+    constexpr static auto bind(data::State<S, A, Repr> const& act, Func k)
+    {
+        return data::toState | toFunc<>([=](S st)
+        {
+            auto&& [x, st_] = data::runState | act | st;
+            return data::runState | (k | x) | st_;
+        });
+    }
+};
+
+template <>
+class MonadBase<data::Parser>
+{
+public:
+    template <typename A, typename Repr, typename Func>
+    constexpr static auto bind(data::Parser<A, Repr> const& p, Func f)
+    {
+        return data::toParser | toFunc<>([=](std::string cs)
+        {
+            auto&& tempResult = data::runParser | p | cs;
+            auto const cont = toGFunc<1> | [f=std::move(f)](auto tu)
+            {
+                auto&& [a, cs] = tu;
+                return return_ || data::runParser | f(a) | cs;
+            };
+            return mconcat || (tempResult >>= cont);
+        });
+    }
+};
+
 template <typename T>
 using MonadType = typename TypeClassTrait<Monad, std::decay_t<T>>::Type;
 
 /////////// MonadPlus //////////
 
 template <template<typename...> class Type, typename... Ts>
-class MonadPlus : public Monoid<Type, Ts...>
+class MonadZero;
+
+template <template<typename...> class Type, typename... Ts>
+class MonadPlus;
+
+template <typename T>
+struct MonadZeroTrait;
+
+template <template <typename...> class C, typename Data, typename... Rest>
+struct MonadZeroTrait<C<Data, Rest...>>
 {
-public:
-    const static decltype(Monoid<Type, Ts...>::mempty) mzero;
-    constexpr static auto mplus = Monoid<Type, Ts...>::mappend;
+    using Type = MonadZero<C, Data>;
 };
 
-template <template<typename...> typename Type, typename... Args>
-const decltype(Monoid<Type, Args...>::mempty) MonadPlus<Type, Args...>::mzero = Monoid<Type, Args...>::mempty;
+template <typename T>
+using MonadZeroType = typename MonadZeroTrait<T>::Type;
 
 template <typename T>
 struct MonadPlusTrait;
@@ -2708,23 +2985,143 @@ struct MonadPlusTrait<C<Data, Rest...>>
 template <typename T>
 using MonadPlusType = typename MonadPlusTrait<T>::Type;
 
-template <template <typename...> class ClassT>
-constexpr auto guardImpl(bool b)
+class Mplus
 {
-    return b ? MonadType<ClassT<_O_>>::return_( _o_) : MonadPlusType<ClassT<_O_>>::mzero;
-}
+public:
+    template <typename T1, typename T2>
+    constexpr auto operator()(T1 t1, T2 t2) const
+    {
+        using MPT = MonadPlusType<T1>;
+        static_assert(std::is_same_v<MPT, MonadPlusType<T2>>);
+        return MPT::mplus | t1 | t2;
+    }
+};
 
-template <>
-constexpr auto guardImpl<data::Range>(bool b)
+constexpr auto mplus = toGFunc<2> | Mplus{};
+
+template <template<typename...> class Type, typename... Ts>
+class MonadZero : public Monoid<Type, Ts...>
 {
-    return data::ownedRange(data::FilterView{Monad<data::Range>::return_(_o_), [b](auto){ return b; }});
-}
+public:
+    const static decltype(Monoid<Type, Ts...>::mempty) mzero;
+};
 
-template <template <typename...> class ClassT>
-constexpr auto guard = data::toFunc([](bool b)
+template <template<typename...> typename Type, typename... Args>
+const decltype(Monoid<Type, Args...>::mempty) MonadZero<Type, Args...>::mzero = Monoid<Type, Args...>::mempty;
+
+template <typename A>
+class MonadZero<data::Parser, A>
 {
-    return guardImpl<ClassT>(b);
-});
+public:
+    constexpr static auto mzero = data::toParser || toFunc<> | [](std::string)
+    {
+        return std::vector<std::tuple<A, std::string>>{};
+    };
+};
+
+template <template<typename...> class Type, typename... Ts>
+class MonadPlus : public MonadZero<Type, Ts...>
+{
+public:
+    constexpr static auto mplus = Monoid<Type, Ts...>::mappend;
+};
+
+template <typename A>
+class MonadPlus<data::Parser, A>
+{
+public:
+    constexpr static auto mplus = toGFunc<2> | [](auto p, auto q)
+    {
+        return data::toParser || toFunc<> | [=](std::string cs)
+        {
+            return (data::runParser | p | cs) <hspp::mplus> (data::runParser | q | cs);
+        };
+    };
+};
+
+/////////// Traversable ///////////
+
+template <template<typename...> typename Type, typename... Args>
+class TraversableBase
+{
+public:
+    constexpr static auto traverse = hspp::sequenceA <o> (fmap | id);
+    constexpr static auto sequenceA = hspp::traverse | id;
+};
+
+template <template<typename...> typename Type, typename... Args>
+class Traversable : public TraversableBase<Type, Args...>
+{
+public:
+    constexpr static auto traverse = toGFunc<2>([](auto&& f, auto&& ta)
+    {
+        auto const consF = toGFunc<2>([&](auto&& x, auto&& ys)
+        {
+            return data::cons <fmap> (f | x) <ap> ys;
+        });
+        using OutterResultDataType = decltype(f <fmap> ta);
+        using ResultDataType = DataType<OutterResultDataType>;
+        using DataT = DataType<ResultDataType>;
+        return data::listFoldr | consF || ApplicativeType<ResultDataType>::pure(Type<DataT>{}) || ta;
+    });
+};
+
+template <typename... Args>
+class Traversable<data::Maybe, Args...> : public TraversableBase<data::Maybe, Args...>
+{
+public:
+    constexpr static auto traverse = toGFunc<2>([](auto&& f, auto&& ta)
+    {
+        if (ta == data::nothing)
+        {
+            using ResultDataType = decltype(f | ta.value());
+            using DataT = DataType<ResultDataType>;
+            return ApplicativeType<ResultDataType>::pure(data::Maybe<DataT>{});
+        }
+        return data::just <fmap> (f | ta.value());
+    });
+};
+
+template <typename... Args>
+class Traversable<std::tuple, Args...> : public TraversableBase<std::tuple, Args...>
+{
+public:
+    constexpr static auto traverse = toGFunc<2>([](auto&& f, auto&& in)
+    {
+        constexpr auto sizeMinusOne = std::tuple_size_v<std::decay_t<decltype(in)>> - 1;
+        auto const func = toGFunc<1>([&](auto&& lastElem)
+        {
+            return std::tuple_cat(subtuple<0, sizeMinusOne>(std::move(in)), std::make_tuple(lastElem));
+        });
+        auto const& last = std::get<sizeMinusOne>(in);
+        return func <fmap> (f | last);
+    });
+};
+
+class DeferredGuard
+{
+public:
+    bool cond;
+};
+
+constexpr auto guard = toFunc<> | [](bool flag)
+{
+    return DeferredGuard{flag};
+};
+
+
+template <typename ClassT>
+constexpr auto guardImpl(bool b)
+{
+    if constexpr (data::isRangeV<ClassT>)
+    {
+        return data::ownedRange(data::FilterView{Monad<data::Range>::return_(_o_), [b](auto){ return b; }});
+    }
+    else
+    {
+        return b ? MonadType<ClassT>::return_( _o_) : MonadPlusType<ReplaceDataTypeWith<ClassT, _O_>>::mzero;
+    }
+}
 
 constexpr auto show = toGFunc<1>([](auto&& d)
 {
@@ -2734,7 +3131,7 @@ constexpr auto show = toGFunc<1>([](auto&& d)
 });
 
 template <typename T>
-constexpr auto read = data::toFunc([](std::string const& d)
+constexpr auto read = data::toFunc<>([](std::string const& d)
 {
     std::stringstream is{d};
     T t;
@@ -2744,22 +3141,28 @@ constexpr auto read = data::toFunc([](std::string const& d)
 
 constexpr auto print = putStrLn <o> show;
 
-template <typename MType, typename T, typename = std::enable_if_t<std::is_same_v<MType, MonadType<T>>, void>>
+template <typename ClassT, typename T, typename = std::enable_if_t<std::is_same_v<MonadType<ClassT>, MonadType<T>>, void>>
 constexpr auto evalDeferredImpl(T&& t)
 {
     return std::forward<T>(t);
 }
 
-template <typename MType, typename T>
+template <typename ClassT, typename T>
 constexpr auto evalDeferredImpl(DeferredPure<T> t)
 {
-    return MType::return_(t.mData);
+    return MonadType<ClassT>::return_(t.mData);
 }
 
-template <typename MType>
+template <typename ClassT>
+constexpr auto evalDeferredImpl(DeferredGuard g)
+{
+    return guardImpl<ClassT>(g.cond);
+}
+
+template <typename ClassT>
 constexpr auto evalDeferred = toGFunc<1>([](auto&& d)
 {
-    return evalDeferredImpl<MType>(d);
+    return evalDeferredImpl<ClassT>(d);
 });
 
 // >>= is right-assocative in C++, have to add some parens when chaining the calls.
@@ -2767,29 +3170,70 @@ template <typename Arg, typename Func, typename Ret = std::invoke_result_t<Func,
 constexpr auto operator>>=(DeferredPure<Arg> const& arg, Func const& func)
 {
     using MType = MonadType<Ret>;
-    return MType::bind(evalDeferred<MType> | arg, func);
+    return MType::bind(evalDeferred<Ret> | arg, func);
 }
 
 template <typename MonadData, typename Func>
 constexpr auto operator>>=(MonadData const& data, Func const& func)
 {
     using MType = MonadType<MonadData>;
-    return MType::bind(data, evalDeferred<MType> <o> func);
+    return MType::bind(data, evalDeferred<MonadData> <o> func);
 }
 
-template <typename Arg, typename MonadData>
-constexpr auto operator>>(DeferredPure<Arg> const& arg, MonadData const& data)
+template <typename Deferred, typename MonadData, typename = std::enable_if_t<isDeferredV<Deferred>, bool>>
+constexpr auto operator>>(Deferred const& arg, MonadData const& data)
 {
     using MType = MonadType<MonadData>;
-    return MType::rshift(evalDeferred<MType> | arg, data);
+    return MType::rshift | (evalDeferred<MonadData> | arg) | data;
+}
+
+template <typename MonadData1, typename MonadData2,
+    std::enable_if_t<std::is_same_v<MonadType<MonadData1>, MonadType<MonadData2>>, bool*> = nullptr>
+constexpr auto operator>>(MonadData1 const& lhs, MonadData2 const& rhs)
+{
+    using MType = MonadType<MonadData1>;
+    return MType::rshift | lhs || rhs;
 }
 
 template <typename MonadData1, typename MonadData2, typename MType = MonadType<MonadData1>,
-    typename = std::enable_if_t<std::is_same_v<MType, MonadType<MonadData2>> || isDeferredPureV<MonadData2>, bool>>
+    typename = std::enable_if_t<isDeferredV<MonadData2>, bool>>
 constexpr auto operator>>(MonadData1 const& lhs, MonadData2 const& rhs)
 {
-    return MType::rshift | lhs || evalDeferred<MType> | rhs;
+    return MType::rshift | lhs || evalDeferred<MonadData1> | rhs;
 }
+
+constexpr auto all = toGFunc<1>([](auto p)
+{
+    return getAll <o> (foldMap | (toAll <o> p));
+});
+
+constexpr auto any = toGFunc<1>([](auto p)
+{
+    return getAny <o> (foldMap | (toAny <o> p));
+});
+
+constexpr auto sum = getSum <o> (foldMap | toSum);
+
+constexpr auto product = getProduct <o> (foldMap | toProduct);
+
+constexpr inline auto elem = any <o> data::equalTo;
+
+constexpr inline auto length = getSum <o> (foldMap || data::const_ | (toSum | 1));
+
+
+constexpr auto triPlus = toGFunc<2> | [](auto p, auto q)
+{
+    return data::toParser <o> data::toFunc<> | [=](std::string cs)
+    {
+        auto tmp = data::runParser | (p <mplus> q) | cs;
+        if (tmp.empty())
+        {
+            return tmp;
+        }
+        tmp.resize(1);
+        return tmp;
+    };
+};
 } // namespace hspp
 
 #endif // HSPP_H
diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index 2c877d9..662d9ce 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -13,7 +13,7 @@ constexpr auto toVector = data::to<std::vector>;
 TEST(Range, 1)
 {
     auto vv = MapView{ProductView{SingleView{42}},
-        toFunc([](std::tuple<int> a) {
+        toFunc<>([](std::tuple<int> a) {
             return std::get<0>(a);
         })};
     auto v = toVector(vv);
@@ -84,9 +84,9 @@ TEST(JoinMapView, 2)
         EXPECT_TRUE(std::equal(result.begin(), result.end(), u.begin()));
     };
     auto f = [](int x)-> std::list<int> { return x%2==0 ? std::list<int>{x} : std::list<int>{}; };
-    const auto filterEven1 = toTEFunc(f);
+    const auto filterEven1 = toTEFunc<>(f);
     test(filterEven1);
-    const auto filterEven2 = toFunc(f);
+    const auto filterEven2 = toFunc<>(f);
     test(filterEven2);
 }
 
@@ -249,14 +249,14 @@ TEST(Functor, vector)
     };
     const TEFunction<int, int> g = std::negate<>{};
     test(g);
-    const auto h = toFunc(std::negate<int>{});
+    const auto h = toFunc<>(std::negate<int>{});
     test(h);
 }
 
 TEST(Functor, Range)
 {
     std::vector<int> const vi{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-    const auto g = toFunc(std::negate<int>{});
+    const auto g = toFunc<>(std::negate<int>{});
     auto h = g <fmap> nonOwnedRange(vi);
     std::vector<int> const result = {-1, -2, -3, -4, -5, -6, -7, -8, -9, -10};
     auto hV = toVector(h);
@@ -282,7 +282,7 @@ TEST(Functor, Maybe)
     };
     const TEFunction<int, int> g = std::negate<>{};
     test(g);
-    const auto h = toFunc(std::negate<int>{});
+    const auto h = toFunc<>(std::negate<int>{});
     test(h);
 }
 
@@ -296,7 +296,7 @@ TEST(Functor, IO)
     };
     const TEFunction<int, int> g = std::negate<>{};
     test(g);
-    const auto h = toFunc(std::negate<int>{});
+    const auto h = toFunc<>(std::negate<int>{});
     test(h);
 }
 
@@ -318,7 +318,7 @@ TEST(Applicative, vector)
     };
     const TEFunction<int, int> g = std::negate<>{};
     test(g);
-    const auto h = toFunc(std::negate<int>{});
+    const auto h = toFunc<>(std::negate<int>{});
     test(h);
 }
 
@@ -367,9 +367,9 @@ TEST(Applicative, range)
 
 TEST(Applicative, tuple)
 {
-    const auto x = std::make_tuple(all | true, 4);
+    const auto x = std::make_tuple(toAll | true, 4);
     const auto result = pure(show) <ap> x;
-    const auto expected = std::make_tuple(all | true, "4");
+    const auto expected = std::make_tuple(toAll | true, "4");
     EXPECT_EQ(result, expected);
 }
 
@@ -422,7 +422,7 @@ TEST(Applicative, Maybe)
     };
     const TEFunction<int, int> g = std::negate<>{};
     test(g);
-    const auto h = toFunc(std::negate<int>{});
+    const auto h = toFunc<>(std::negate<int>{});
     test(h);
 }
 
@@ -436,7 +436,7 @@ TEST(Applicative, IO)
     };
     const TEFunction<int, int> g = std::negate<>{};
     test(g);
-    const auto h = toFunc(std::negate<int>{});
+    const auto h = toFunc<>(std::negate<int>{});
     test(h);
 }
 
@@ -460,7 +460,7 @@ TEST(Applicative, GenericFunction)
 
 TEST(Compose, x)
 {
-    constexpr auto neg = toFunc(std::negate<int>{});
+    constexpr auto neg = toFunc<>(std::negate<int>{});
     const auto pos = neg <o> neg;
     EXPECT_EQ(pos(1), 1);
 }
@@ -485,7 +485,7 @@ TEST(Monad, list)
     auto f = [](int x)-> std::list<int> { return x%2==0 ? std::list<int>{x} : std::list<int>{}; };
     const TEFunction<std::list<int>, int> filterEven1 = f;
     test(filterEven1);
-    const auto filterEven2 = toFunc(f);
+    const auto filterEven2 = toFunc<>(f);
     test(filterEven2);
 }
 
@@ -502,7 +502,7 @@ TEST(Monad, list2)
     auto const thisAndNeg = [](int x) { return std::list<int>{x, -x}; };
     const TEFunction<std::list<int>, int> thisAndNeg1 = thisAndNeg;
     test(thisAndNeg1);
-    const auto thisAndNeg2 = toFunc(thisAndNeg);
+    const auto thisAndNeg2 = toFunc<>(thisAndNeg);
     test(thisAndNeg2);
 }
 
@@ -517,16 +517,16 @@ TEST(Monad, Range)
         EXPECT_TRUE(std::equal(result.begin(), result.end(), u.begin()));
     };
     auto const thisAndNeg = [](int x) { return ownedRange(ChainView{SingleView{x}, SingleView{-x}}); };
-    const auto thisAndNeg2 = toFunc(thisAndNeg);
+    const auto thisAndNeg2 = toFunc<>(thisAndNeg);
     test(thisAndNeg2);
 }
 
 TEST(Monad, tuple)
 {
-    auto const thisAndRepr = [](auto x) { return std::make_tuple(all | true, show | x); };
-    auto const x = std::make_tuple(all | false, true);
+    auto const thisAndRepr = [](auto x) { return std::make_tuple(toAll | true, show | x); };
+    auto const x = std::make_tuple(toAll | false, true);
     auto const result = x >>= thisAndRepr;
-    const auto expected = std::make_tuple(all | false, "true"s);
+    const auto expected = std::make_tuple(toAll | false, "true"s);
     EXPECT_EQ(result, expected);
 }
 
@@ -543,7 +543,7 @@ TEST(Monad, Maybe)
     };
     auto const filterEven = [](int x)-> Maybe<int> { return x%2==0 ? Maybe<int>{x} : Maybe<int>{}; };
     const TEFunction<Maybe<int>, int> filterEven1 = filterEven;
-    const auto filterEven2 = toFunc(filterEven);
+    const auto filterEven2 = toFunc<>(filterEven);
     test(filterEven1);
     test(filterEven2);
 }
@@ -587,8 +587,8 @@ TEST(Monad, IO)
 
 TEST(Monad, Function)
 {
-    constexpr auto u = toFunc([](std::string const& str) { return str.size(); });
-    constexpr auto f = toFunc([](size_t i, std::string const& str) { return !str.empty() && i > 0; });
+    constexpr auto u = toFunc<>([](std::string const& str) { return str.size(); });
+    constexpr auto f = toFunc<>([](size_t i, std::string const& str) { return !str.empty() && i > 0; });
     constexpr auto y = u >>= f;
     EXPECT_EQ(y(""), false);
     EXPECT_EQ(y("true"), true);
@@ -604,7 +604,7 @@ TEST(Monad, GenericFunction)
 
 TEST(Monad, Function2)
 {
-    constexpr auto f = toFunc([](std::string const& str, size_t i) { return str.size() == i; });
+    constexpr auto f = toFunc<>([](std::string const& str, size_t i) { return str.size() == i; });
     constexpr auto y = toFunc<std::string, size_t>(show) >>= f;
     EXPECT_EQ(y(1U), true);
     EXPECT_EQ(y(3U), false);
@@ -612,7 +612,7 @@ TEST(Monad, Function2)
 
 TEST(Monad, return_)
 {
-    constexpr auto f = toFunc([](int i, std::string const& str) { return !str.empty() && i > 0; });
+    constexpr auto f = toFunc<>([](int i, std::string const& str) { return !str.empty() && i > 0; });
     constexpr auto x = Monad<Function, const std::string&>::return_(5);
     EXPECT_EQ(x(""), 5);
     constexpr auto y = x >>= f;
@@ -622,25 +622,40 @@ TEST(Monad, return_)
 
 TEST(FunctionOp, bar)
 {
-    constexpr auto f = toFunc(std::multiplies<int>{});
+    constexpr auto f = toFunc<>(std::multiplies<int>{});
     constexpr auto r = f | 2 | 5;
     EXPECT_EQ(r, 10);
 }
 
 TEST(FunctionOp, bars)
 {
-    constexpr auto f = toFunc(std::multiplies<int>{});
-    constexpr auto g = toFunc(std::negate<int>{});
+    constexpr auto f = toFunc<>(std::multiplies<int>{});
+    constexpr auto g = toFunc<>(std::negate<int>{});
     constexpr auto r = g || f | 2 | 5;
     EXPECT_EQ(r, -10);
 }
 
+TEST(FunctionOp, flipBar)
+{
+    constexpr auto f = toFunc<>(std::minus<int>{});
+    constexpr auto r = 5 & (2 & f);
+    EXPECT_EQ(r, -3);
+}
+
+TEST(FunctionOp, flipBar2)
+{
+    constexpr auto f = toFunc<>(std::negate<int>{});
+    constexpr auto g = toFunc<>([](int x) { return x + 1; });
+    constexpr auto r = 5 & f & g;
+    EXPECT_EQ(r, -4);
+}
+
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wenum-compare"
 TEST(on, 1)
 {
-    constexpr auto f = toFunc(std::equal_to<int>{});
-    constexpr auto g = toFunc([](int e){ return e > 0; });
+    constexpr auto f = toFunc<>(std::equal_to<int>{});
+    constexpr auto g = toFunc<>([](int e){ return e > 0; });
     constexpr auto r = f <on> g | 2 | -4;
     EXPECT_EQ(r, false);
     constexpr auto s = f <on> g | 2 | 4;
@@ -650,7 +665,7 @@ TEST(on, 1)
 
 TEST(IO, myAction)
 {
-    constexpr auto f = toFunc(
+    constexpr auto f = toFunc<>(
         [](std::string l, std::string r)
         {
             return l + r;
@@ -662,18 +677,18 @@ TEST(IO, myAction)
 
 TEST(Function, myFunc)
 {
-    constexpr auto myFunc = toFunc(std::plus<int>{})
-                     <fmap> toFunc([](int x) { return x + 3;})
-                      <ap> toFunc([](int x) { return x * 100; });
+    constexpr auto myFunc = toFunc<>(std::plus<int>{})
+                     <fmap> toFunc<>([](int x) { return x + 3;})
+                      <ap> toFunc<>([](int x) { return x * 100; });
     EXPECT_EQ(myFunc(5), 508);
 }
 
 TEST(Function, myFunc2)
 {
-    constexpr auto myFunc = toFunc([](float x, float y, float z) { return std::vector{x, y, z}; })
-                     <fmap> toFunc([](float x) { return x + 3;})
-                      <ap> toFunc([](float x) { return x * 2; })
-                      <ap> toFunc([](float x) { return x / 2; });
+    constexpr auto myFunc = toFunc<>([](float x, float y, float z) { return std::vector{x, y, z}; })
+                     <fmap> toFunc<>([](float x) { return x + 3;})
+                      <ap> toFunc<>([](float x) { return x * 2; })
+                      <ap> toFunc<>([](float x) { return x / 2; });
     auto const result = myFunc(5);
     auto const expected = {8.0,10.0,2.5};
     EXPECT_TRUE(std::equal(result.begin(), result.end(), expected.begin()));
@@ -736,7 +751,7 @@ TEST(id, 1)
 
 TEST(unCurry, 1)
 {
-    constexpr auto f = toFunc([](std::vector<std::string> acc, std::string l)
+    constexpr auto f = toFunc<>([](std::vector<std::string> acc, std::string l)
     {
         acc.push_back(l);
         return acc;
@@ -748,7 +763,7 @@ TEST(unCurry, 1)
 
 TEST(foldl, 1)
 {
-    constexpr auto f = toFunc([](std::string acc, std::string l)
+    constexpr auto f = toFunc<>([](std::string acc, std::string l)
     {
         return acc + l;
     });
@@ -760,7 +775,7 @@ TEST(foldl, 1)
 
 TEST(foldl, 2)
 {
-    constexpr auto f = toFunc([](std::vector<std::string> acc, std::string l)
+    constexpr auto f = toFunc<>([](std::vector<std::string> acc, std::string l)
     {
         acc.push_back(l);
         return acc;
@@ -773,7 +788,7 @@ TEST(foldl, 2)
 
 TEST(foldr, 1)
 {
-    constexpr auto f = toFunc([](std::string l, std::string acc)
+    constexpr auto f = toFunc<>([](std::string l, std::string acc)
     {
         return l + acc;
     });
@@ -876,10 +891,10 @@ TEST(Monoid, list)
 
 TEST(Monoid, ZipList)
 {
-    auto const nested = std::list{zipList || sum <fmap> std::list{1, 2}, zipList || sum <fmap> std::list{3, 4}};
+    auto const nested = std::list{toZipList || toSum <fmap> std::list{1, 2}, toZipList || toSum <fmap> std::list{3, 4}};
     auto v = mconcat | nested;
     auto const result = toVector(v);
-    auto const expected = sum <fmap> std::vector{4, 6};
+    auto const expected = toSum <fmap> std::vector{4, 6};
     EXPECT_EQ(result, expected);
 }
 
@@ -917,72 +932,76 @@ TEST(Monoid, range3)
 
 TEST(Monoid, maybe)
 {
-    auto const nested = std::list{just(product(2)), Maybe<Product<int>>{}, just(product(3))};
+    auto const nested = std::list{just(toProduct(2)), Maybe<Product<int>>{}, just(toProduct(3))};
     auto const result = mconcat | nested;
-    auto const expected = just(product(6));
+    auto const expected = just(toProduct(6));
     EXPECT_EQ(result, expected);
 }
 
-TEST(Monoid, product)
+TEST(Monoid, toProduct)
 {
-    auto const a = product | 1.5;
-    auto const b = product | 2.0;
+    auto const a = toProduct | 1.5;
+    auto const b = toProduct | 2.0;
     auto nested = std::vector{a, b};
     auto v = mconcat | nested;
     auto const result = v;
     auto const expected = 3.0;
     EXPECT_EQ(expected, result.get());
 
-    auto const result2 = getProduct || (product | 3) <mappend> (product | 4) <mappend> (product | 2);
+    auto const result2 = getProduct || (toProduct | 3) <mappend> (toProduct | 4) <mappend> (toProduct | 2);
     EXPECT_EQ(result2, 24);
 
-    auto const result3 = getProduct <o> mconcat || fmap | product | std::vector{3, 4, 2};
+    auto const result3 = getProduct <o> mconcat || fmap | toProduct | std::vector{3, 4, 2};
     EXPECT_EQ(result3, 24);
 }
 
 TEST(Monoid, product2)
 {
-    auto const result = getProduct <o> mconcat <o> (map | product) || std::vector{3, 4, 2};
+    auto const result = getProduct <o> mconcat <o> (map | toProduct) || std::vector{3, 4, 2};
     EXPECT_EQ(result, 24);
 }
 
-TEST(Monoid, sum)
+TEST(Monoid, toSum)
 {
-    auto const result = getSum <o> mconcat <o> (map | sum) || std::vector{3, 4, 2};
+    auto const result = getSum <o> mconcat <o> (map | toSum) || std::vector{3, 4, 2};
     EXPECT_EQ(result, 9);
 }
 
-TEST(Monoid, all)
+TEST(Monoid, toAll)
 {
-    auto const result = getAll <o> mconcat <o> (map | all) || std::list{true, false, true};
+    auto const result = getAll <o> mconcat <o> (map | toAll) || std::list{true, false, true};
     EXPECT_EQ(result, false);
+    auto const result2 = all | id | std::list{true, false, true};
+    EXPECT_EQ(result2, false);
 }
 
 TEST(Monoid, any)
 {
-    auto const result = getAny <o> mconcat <o> (map | any) || std::list{true, false, true};
+    auto const result = getAny <o> mconcat <o> (map | toAny) || std::list{true, false, true};
     EXPECT_EQ(result, true);
+    auto const result2 = any | id | std::list{true, false, true};
+    EXPECT_EQ(result2, true);
 }
 
 TEST(Monoid, first)
 {
-    auto const result = getFirst <o> mconcat <o> (map | first) || std::list<Maybe<int>>{nothing, just(2), just(3)};
+    auto const result = getFirst <o> mconcat <o> (map | toFirst) || std::list<Maybe<int>>{nothing, just(2), just(3)};
     EXPECT_EQ(result, just(2));
 }
 
-TEST(Monoid, last)
+TEST(Monoid, toLast)
 {
-    auto const result = getLast <o> mconcat <o> (map | last) || std::list<Maybe<int>>{nothing, just(2), just(3)};
+    auto const result = getLast <o> mconcat <o> (map | toLast) || std::list<Maybe<int>>{nothing, just(2), just(3)};
     EXPECT_EQ(result, just(3));
 }
 
 TEST(Monoid, Ordering)
 {
-    constexpr auto length = toFunc([](std::string const& x)
+    constexpr auto length = toFunc<>([](std::string const& x)
     {
         return x.length();
     });
-    auto const lengthCompare = toFunc([=](std::string const& x, std::string const& y)
+    auto const lengthCompare = toFunc<>([=](std::string const& x, std::string const& y)
     {
         return ((length | x) <compare> (length | y)) <mappend> (x <compare> y);
     });
@@ -994,34 +1013,34 @@ TEST(Monoid, Ordering)
 
 TEST(Monoid, GenericFunction)
 {
-    auto const f = toGFunc<1>([](auto u){ return product | (u+1); });
-    auto const g = toGFunc<1>([](auto u){ return product | (u*2); });
+    auto const f = toGFunc<1>([](auto u){ return toProduct | (u+1); });
+    auto const g = toGFunc<1>([](auto u){ return toProduct | (u*2); });
     auto const result = mappend | f | g;
     EXPECT_EQ(result(24).get(), 1200);
 }
 
 TEST(Monoid, Function)
 {
-    auto const f = toFunc([](int u){ return product | (u+1); });
-    auto const g = toFunc([](int u){ return product | (u*2); });
+    auto const f = toFunc<>([](int u){ return toProduct | (u+1); });
+    auto const g = toFunc<>([](int u){ return toProduct | (u*2); });
     auto const result = mappend | f | g;
     EXPECT_EQ(result(24).get(), 1200);
 }
 
 TEST(Monoid, Tuple)
 {
-    auto const x = std::make_tuple(sum | 1, std::string{"123"});
-    auto const y = std::make_tuple(sum | 0, std::string{"23"});
+    auto const x = std::make_tuple(toSum | 1, std::string{"123"});
+    auto const y = std::make_tuple(toSum | 0, std::string{"23"});
     auto const z = x <mappend> y;
-    EXPECT_EQ(z, std::make_tuple(sum | 1, std::string("12323")));
+    EXPECT_EQ(z, std::make_tuple(toSum | 1, std::string("12323")));
 
     auto const result = mconcat | std::list{x, y};
-    EXPECT_EQ(result, std::make_tuple(sum | 1, std::string("12323")));
+    EXPECT_EQ(result, std::make_tuple(toSum | 1, std::string("12323")));
 }
 
-TEST(Monoid, endo)
+TEST(Monoid, toEndo)
 {
-    auto const result = appEndo || (endo | id) <mappend> (endo | show);
+    auto const result = appEndo || (toEndo | id) <mappend> (toEndo | show);
     EXPECT_EQ(result | 2, "2");
 }
 
@@ -1037,8 +1056,8 @@ TEST(Foldable, list)
 TEST(Foldable, list2)
 {
     auto const nested = std::vector{3, 4};
-    auto const result = foldMap | sum | nested;
-    auto const expected = sum | 7;
+    auto const result = foldMap | toSum | nested;
+    auto const expected = toSum | 7;
     EXPECT_EQ(result, expected);
 }
 
@@ -1050,6 +1069,14 @@ TEST(Foldable, list3)
     EXPECT_EQ(result, expected);
 }
 
+TEST(Foldable, maybe)
+{
+    auto const nested = just | 3;
+    auto const result = foldMap | toSum | nested;
+    auto const expected = toSum | 3;
+    EXPECT_EQ(result, expected);
+}
+
 TEST(Foldable, tuple)
 {
     auto const t = std::tuple{3, false};
@@ -1062,6 +1089,30 @@ TEST(Foldable, tuple)
     EXPECT_EQ(result3, false);
 }
 
+TEST(Traversable, tuple)
+{
+    auto const t = std::tuple{3, just | false};
+    auto const result = sequenceA | t;
+    auto const expected = just | std::tuple{3, false};
+    EXPECT_EQ(result, expected);
+}
+
+TEST(Traversable, maybe)
+{
+    auto const result = sequenceA | just(std::vector{4});
+    auto const expected = std::vector{just | 4};
+    EXPECT_EQ(result, expected);
+}
+
+TEST(Traversable, vector)
+{
+    auto const result = sequenceA || fmap | just | std::vector{1, 2, 3};
+    auto const expected = just | std::vector{1, 2, 3};
+    EXPECT_EQ(result, expected);
+    auto const result2 = sequenceA <o> (fmap | just) | std::vector{1, 2, 3};
+    EXPECT_EQ(result2, expected);
+}
+
 TEST(Maybe, 1)
 {
     auto result = just("andy"s) <mappend> nothing;
@@ -1079,7 +1130,7 @@ TEST(Monad, WalkTheLine)
 {
     using Birds = int;
     using Pole = std::pair<Birds, Birds>;
-    constexpr auto landLeft = toFunc([](Birds n, Pole p)
+    constexpr auto landLeft = toFunc<>([](Birds n, Pole p)
     {
         auto [left, right] = p;
         if (std::abs((left + n) - right) < 4) 
@@ -1088,7 +1139,7 @@ TEST(Monad, WalkTheLine)
         }
         return Maybe<Pole>{};
     });
-    constexpr auto landRight = toFunc([](Birds n, Pole p)
+    constexpr auto landRight = toFunc<>([](Birds n, Pole p)
     {
         auto [left, right] = p;
         if (std::abs((right + n) - left) < 4) 
@@ -1103,7 +1154,7 @@ TEST(Monad, WalkTheLine)
     auto const result2 = ((((return_ | Pole{0,0}) >>= (landLeft | 1)) >>= (landRight | 4)) >>= (landLeft | -1)) >>= (landRight | -2);
     EXPECT_EQ(result2, nothing);
 
-    constexpr auto banana = toFunc([](Pole)
+    constexpr auto banana = toFunc<>([](Pole)
     {
         return Maybe<Pole>{};
     });
@@ -1114,7 +1165,7 @@ TEST(Monad, WalkTheLine)
 TEST(Monad, vec)
 {
     auto const result = std::vector{1,2}
-                    >>= toFunc([](int n)
+                    >>= toFunc<>([](int n)
                     {
                         return std::vector{'a','b'}
                             >>= [=](char ch)
@@ -1132,7 +1183,7 @@ TEST(Monad, vec)
 
 TEST(Applicative, vec)
 {
-    auto const result = toFunc([=](int n, char ch)
+    auto const result = toFunc<>([=](int n, char ch)
     {
         return std::make_pair(n,ch);
     })
@@ -1159,25 +1210,30 @@ TEST(Copy, View)
 
 TEST(MonadPlus, guard)
 {
-    auto const result = guard<Maybe>(5 > 2);
-    EXPECT_EQ(result, just(_o_));
+    auto const result = guard(5 > 2) >> just(1);
+    EXPECT_EQ(result, just(1));
 
-    auto const result1 = guard<Maybe>(1 > 2);
+    auto const result1 = guard(1 > 2) >> just(1);
     EXPECT_EQ(result1, nothing);
 
-    auto const result3 = guard<std::vector>(5 > 2);
-    EXPECT_EQ(result3, std::vector{_o_});
+    auto const result3 = guard(5 > 2) >> std::vector{2};
+    EXPECT_EQ(result3, std::vector{2});
 
-    auto const result4 = guard<std::vector>(1 > 2);
+    auto const result4 = guard(1 > 2) >> std::vector{2};
     EXPECT_TRUE(result4.empty());
 
-    auto const result5 = guard<Range>(1 > 2);
+    auto const result5 = guard(1 > 2) >> ownedRange(SingleView{4});
     EXPECT_TRUE(toVector(result5).empty());
 
-    auto const result6 = guard<Range> | ('7' <elem> (show | 567 ));
-    EXPECT_EQ(toVector(result6).at(0), _o_);
+    auto const result6 = (guard | ('7' <elem> (show | 567 ))) >> ownedRange(SingleView{4});
+    EXPECT_EQ(toVector(result6).at(0), 4);
 
-    auto const func = toGFunc<1>([](auto x) { return (guard<Range> | ('7' <elem> (show | x))) >> (return_ | x); });
+    auto const func = toGFunc<1>([](auto x)
+    {
+        return ownedRange(SingleView{4})
+            >> (guard || '7' <elem> (show | x))
+            >> (return_ | x);
+    });
     auto const l = std::vector{7, 9, 17, 22};
     auto const result7 = func <fmap> nonOwnedRange(l);
     auto const expected7 = std::vector{7, 17};
@@ -1196,3 +1252,155 @@ TEST(const_, x)
     EXPECT_EQ(foldl | const_ | 0 | v, 0);
     EXPECT_EQ(foldr | const_ | 0 | v, 1);
 }
+
+constexpr auto item = toParser | toFunc<>([](std::string cs) -> std::vector<std::tuple<char, std::string>>
+{
+    if (cs.empty())
+    {
+        return {};
+    }
+    return {{cs.front(), cs.substr(1)}};
+});
+
+constexpr auto sat = toGFunc<1> | [](auto p)
+{
+    return item >>= toFunc<> | [=](char c) { return
+        toParser || toFunc<> | [flag = p | c, posParser = Monad<Parser>::return_ | c, negParser = MonadZero<Parser, char>::mzero]
+        (std::string cs) -> std::vector<std::tuple<char, std::string>>
+        {
+            return flag ? (runParser | posParser | cs) : (runParser | negParser | cs);
+        };
+    };
+};
+
+constexpr auto char_ = toFunc<> | [](char c)
+{
+    return sat | (equalTo | c);
+};
+
+template <typename Func>
+class YCombinator
+{
+    Func mFunc;
+public:
+    constexpr YCombinator(Func func)
+    : mFunc{std::move(func)}
+    {}
+    template <typename... Args>
+    constexpr auto operator()(Args&&... args) const
+    {
+        return mFunc(*this, args...);
+    }
+};
+
+constexpr auto yCombinator = toGFunc<1> | [](auto func)
+{
+    return YCombinator<decltype(func)>{std::move(func)};
+};
+
+class StringParser;
+
+auto stringImpl(std::string const& cs)
+    -> Parser<std::string, StringParser>;
+
+class StringParser
+{
+    std::string mCs;
+public:
+    StringParser(std::string cs)
+    : mCs{std::move(cs)}
+    {}
+    auto operator()(std::string str) const -> std::vector<std::tuple<std::string, std::string>>
+    {
+        if (mCs.empty())
+        {
+            auto const p1 = Monad<Parser>::return_ | ""s;
+            return runParser | p1 | str;
+        }
+        auto const c = mCs.front();
+        auto const cr = mCs.substr(1);
+        auto const p2 =
+            (char_ | c)
+                >> stringImpl(cr)
+                >> (return_ | mCs);
+        return runParser | p2 | str;
+    }
+};
+
+auto stringImpl(std::string const& cs)
+    -> Parser<std::string, StringParser>
+{
+    return toParser || toFunc<> | StringParser{cs};
+};
+
+constexpr auto string = toFunc<> || [](std::string const& cs)
+{
+    return stringImpl(cs);
+};
+
+template <typename A, typename Repr>
+constexpr auto manyImpl(Parser<A, Repr> p)
+    -> TEParser<std::vector<A>>;
+
+constexpr auto many1 = toGFunc<1> | [](auto p)
+{
+    return
+    p >>= [=](auto a) { return
+       manyImpl(p) >>= [=](auto as) { return
+        return_ | (a <cons> as);
+        };
+       };
+};
+
+template <typename A, typename Repr>
+constexpr auto manyImpl(Parser<A, Repr> p)
+    -> TEParser<std::vector<A>>
+{
+    return toTEParser || triPlus | (many1 | p) | (Monad<Parser>::return_ | std::vector<A>{});
+}
+
+constexpr auto many = toGFunc<1> | [](auto p)
+{
+    return manyImpl(p);
+};
+
+TEST(Parser, item)
+{
+    constexpr auto p =
+        item >>= toFunc<> | [](char c) { return
+            item >>
+            item >>= toFunc<> | [c](char d) {
+                return return_ | std::make_tuple(c, d);
+            };
+        };
+
+    auto const result = runParser | p | "123";
+    auto const expected = std::make_tuple('1', '3');
+    EXPECT_EQ(std::get<0>(result.front()), expected);
+}
+
+TEST(Parser, string)
+{
+    (void)yCombinator;
+
+    auto const result = runParser | (string | ""s) | "123";
+    auto const expected = ""s;
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
+
+    auto const result2 = runParser | (string | "13") | "123";
+    EXPECT_TRUE(result2.empty());
+
+    auto const result3 = runParser | (string | "12") | "123";
+    auto const expected3 = "12"s;
+    EXPECT_EQ(std::get<0>(result3.at(0)), expected3);
+
+    auto const result4 = runParser | (string | "123") | "12";
+    EXPECT_TRUE(result4.empty());
+}
+
+TEST(Parser, many)
+{
+    auto const result = runParser || many | (string | "12"s) || "12123";
+    auto const expected = std::vector{"12"s, "12"s};
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
+}
\ No newline at end of file

From dad1b9c7899143b4f938dfaf8b24d7e8de756ae5 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 20:18:51 +0800
Subject: [PATCH 02/16] sep

---
 test/hspp/test.cpp | 36 +++++++++++++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index 662d9ce..fe6c2f4 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1364,6 +1364,33 @@ constexpr auto many = toGFunc<1> | [](auto p)
     return manyImpl(p);
 };
 
+template <typename A, typename Repr, typename B, typename Repr1>
+constexpr auto sepByImpl(Parser<A, Repr> p, Parser<B, Repr1> sep)
+    -> TEParser<std::vector<A>>;
+
+constexpr auto sepBy1 = toGFunc<2> | [](auto p, auto sep)
+{
+    return p
+    >>= [=](auto a) { return
+        (many | (sep >>= p))
+        >>= [=](auto as) { return
+            return_ || a <cons>  as;
+        };
+    };
+};
+
+template <typename A, typename Repr, typename B, typename Repr1>
+constexpr auto sepByImpl(Parser<A, Repr> p, Parser<B, Repr1> sep)
+    -> TEParser<std::vector<A>>
+{
+    return toTEParser || triPlus | (p <sepBy1> sep) | (Monad<Parser>::return_ | std::vector<A>{});
+}
+
+constexpr auto sepBy = toGFunc<2> | [](auto p, auto sep)
+{
+    return sepByImpl(p, sep);
+};
+
 TEST(Parser, item)
 {
     constexpr auto p =
@@ -1403,4 +1430,11 @@ TEST(Parser, many)
     auto const result = runParser || many | (string | "12"s) || "12123";
     auto const expected = std::vector{"12"s, "12"s};
     EXPECT_EQ(std::get<0>(result.at(0)), expected);
-}
\ No newline at end of file
+}
+
+// TEST(Parser, seqBy)
+// {
+//     auto const result = runParser | (sepBy | (string | "1"s) | (char_ | '2')) || "12123";
+//     auto const expected = std::vector{"1"s, "1"s};
+//     EXPECT_EQ(std::get<0>(result.at(0)), expected);
+// }
\ No newline at end of file

From 67d4d36bad30aa0c2016a80efa980c5e4dcab081 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 20:40:08 +0800
Subject: [PATCH 03/16] chainl

---
 test/hspp/test.cpp | 41 ++++++++++++++++++++++++++++++++---------
 1 file changed, 32 insertions(+), 9 deletions(-)

diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index fe6c2f4..6767ec0 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1364,10 +1364,6 @@ constexpr auto many = toGFunc<1> | [](auto p)
     return manyImpl(p);
 };
 
-template <typename A, typename Repr, typename B, typename Repr1>
-constexpr auto sepByImpl(Parser<A, Repr> p, Parser<B, Repr1> sep)
-    -> TEParser<std::vector<A>>;
-
 constexpr auto sepBy1 = toGFunc<2> | [](auto p, auto sep)
 {
     return p
@@ -1381,9 +1377,8 @@ constexpr auto sepBy1 = toGFunc<2> | [](auto p, auto sep)
 
 template <typename A, typename Repr, typename B, typename Repr1>
 constexpr auto sepByImpl(Parser<A, Repr> p, Parser<B, Repr1> sep)
-    -> TEParser<std::vector<A>>
 {
-    return toTEParser || triPlus | (p <sepBy1> sep) | (Monad<Parser>::return_ | std::vector<A>{});
+    return toParser || triPlus | (p <sepBy1> sep) | (Monad<Parser>::return_ | std::vector<A>{});
 }
 
 constexpr auto sepBy = toGFunc<2> | [](auto p, auto sep)
@@ -1391,6 +1386,27 @@ constexpr auto sepBy = toGFunc<2> | [](auto p, auto sep)
     return sepByImpl(p, sep);
 };
 
+constexpr auto chainl1 = toGFunc<2> | [](auto p, auto op)
+{
+    auto const rest = yCombinator | [=](auto const& self, auto a)
+    {
+        auto const lhs =
+            op >>= [&](auto f) { return
+                p >>= [&](auto b) { return
+                    return_ || self | (f | a | b);
+                };
+            };
+        auto const rhs = return_ | a;
+        return lhs <triPlus> rhs;
+    };
+    return p >>= rest;
+};
+
+constexpr auto chainl = toGFunc<2> | [](auto p, auto op, auto a)
+{
+    return (p <chainl1> op) <triPlus> (Monad<Parser>::return_ | a);
+};
+
 TEST(Parser, item)
 {
     constexpr auto p =
@@ -1432,9 +1448,16 @@ TEST(Parser, many)
     EXPECT_EQ(std::get<0>(result.at(0)), expected);
 }
 
-// TEST(Parser, seqBy)
-// {
+TEST(Parser, seqBy)
+{
+    (void)sepBy;
 //     auto const result = runParser | (sepBy | (string | "1"s) | (char_ | '2')) || "12123";
 //     auto const expected = std::vector{"1"s, "1"s};
 //     EXPECT_EQ(std::get<0>(result.at(0)), expected);
-// }
\ No newline at end of file
+}
+
+TEST(Parser, chainl1)
+{
+    (void)chainl1;
+    (void)chainl;
+}
\ No newline at end of file

From 33063f24c41662bf88d9acec071c24c33b5a94d6 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 20:48:08 +0800
Subject: [PATCH 04/16] space.

---
 test/hspp/test.cpp | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index 6767ec0..92d8ff7 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -3,6 +3,7 @@
 #include <list>
 #include <gtest/gtest.h>
 #include <cmath>
+#include <cctype>
 
 using namespace hspp;
 using namespace hspp::data;
@@ -1407,6 +1408,13 @@ constexpr auto chainl = toGFunc<2> | [](auto p, auto op, auto a)
     return (p <chainl1> op) <triPlus> (Monad<Parser>::return_ | a);
 };
 
+constexpr auto isSpace = toFunc<> | [](char c)
+{
+    return isspace(c);
+};
+
+const auto space = many || sat | isSpace;
+
 TEST(Parser, item)
 {
     constexpr auto p =
@@ -1460,4 +1468,11 @@ TEST(Parser, chainl1)
 {
     (void)chainl1;
     (void)chainl;
-}
\ No newline at end of file
+}
+
+TEST(Parser, space)
+{
+    auto const result = runParser || space || "  12123";
+    auto const expected = std::vector{' ', ' '};
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
+}

From 391b807f61e546202744f7c11c58cb2ad0a6dd15 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 20:54:21 +0800
Subject: [PATCH 05/16] token.

---
 test/hspp/test.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index 92d8ff7..3b3bd81 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1415,6 +1415,15 @@ constexpr auto isSpace = toFunc<> | [](char c)
 
 const auto space = many || sat | isSpace;
 
+constexpr auto token = toGFunc<1> | [](auto p)
+{
+    return p >>= [](auto a) { return
+        space >>
+        (return_ | a);
+    };
+};
+
+
 TEST(Parser, item)
 {
     constexpr auto p =
@@ -1476,3 +1485,10 @@ TEST(Parser, space)
     auto const expected = std::vector{' ', ' '};
     EXPECT_EQ(std::get<0>(result.at(0)), expected);
 }
+
+TEST(Parser, token)
+{
+    auto const result = runParser || token | (string | "12") || "12 123";
+    auto const expected = "12"s;
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
+}

From aa0103060223004bd160e5fbbb7ddca5fcaa38da Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 20:58:42 +0800
Subject: [PATCH 06/16] symb apply.

---
 test/hspp/test.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index 3b3bd81..18257b1 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1423,6 +1423,13 @@ constexpr auto token = toGFunc<1> | [](auto p)
     };
 };
 
+constexpr auto symb = token <o> string;
+
+constexpr auto apply = toGFunc<1> | [](auto p)
+{
+    return runParser | (space >> p);
+};
+
 
 TEST(Parser, item)
 {
@@ -1492,3 +1499,17 @@ TEST(Parser, token)
     auto const expected = "12"s;
     EXPECT_EQ(std::get<0>(result.at(0)), expected);
 }
+
+TEST(Parser, symb)
+{
+    auto const result = runParser || symb | "12" || "12 123";
+    auto const expected = "12"s;
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
+}
+
+TEST(Parser, apply)
+{
+    auto const result = apply || symb | "12" || " 12 123";
+    auto const expected = "12"s;
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
+}

From 5f1ecc85b51c6da730e12a443cf056532a6fe7c5 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 21:15:19 +0800
Subject: [PATCH 07/16] ops

---
 test/hspp/test.cpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index 18257b1..c53ea8d 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1513,3 +1513,23 @@ TEST(Parser, apply)
     auto const expected = "12"s;
     EXPECT_EQ(std::get<0>(result.at(0)), expected);
 }
+
+enum class Op
+{
+    kADD,
+    kSUB,
+    kMUL,
+    kDIV
+};
+
+auto const addOp = ((symb | "+") >> (return_ | Op::kADD)) <triPlus> ((symb | "-") >> (return_ | Op::kSUB));
+auto const mulOp = ((symb | "*") >> (return_ | Op::kMUL)) <triPlus> ((symb | "/") >> (return_ | Op::kDIV));
+
+TEST(Parser, ops)
+{
+    auto const result = apply || addOp || " +  * /-";
+    EXPECT_EQ(std::get<0>(result.at(0)), Op::kADD);
+
+    auto const result2 = apply || mulOp || "   * /-";
+    EXPECT_EQ(std::get<0>(result2.at(0)), Op::kMUL);
+}

From a969f7b162f44dd7121bb61df039aced034fec49 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 22:18:38 +0800
Subject: [PATCH 08/16] good digit

---
 include/hspp.h     |  2 +-
 test/hspp/test.cpp | 99 +++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 90 insertions(+), 11 deletions(-)

diff --git a/include/hspp.h b/include/hspp.h
index 6fe04a0..a0d7483 100644
--- a/include/hspp.h
+++ b/include/hspp.h
@@ -1586,7 +1586,7 @@ template <typename A, typename Repr>
 constexpr auto toTEParserImpl(Parser<A, Repr> p)
 {
     return TEParser<A>{(runParser | p)};
-};
+}
 
 constexpr auto toTEParser = toGFunc<1> | [](auto p)
 {
diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index c53ea8d..a687ef3 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1387,23 +1387,29 @@ constexpr auto sepBy = toGFunc<2> | [](auto p, auto sep)
     return sepByImpl(p, sep);
 };
 
-constexpr auto chainl1 = toGFunc<2> | [](auto p, auto op)
+template <typename A, typename Repr, typename Op>
+constexpr auto chainl1Impl(Parser<A, Repr> p, Op op)
 {
-    auto const rest = yCombinator | [=](auto const& self, auto a)
+    auto const rest = toGFunc<1> | yCombinator | [=](auto const& self, auto a) -> TEParser<A>
     {
         auto const lhs =
             op >>= [&](auto f) { return
                 p >>= [&](auto b) { return
-                    return_ || self | (f | a | b);
+                    Monad<Parser>::return_ || self(f | a | b);
                 };
             };
-        auto const rhs = return_ | a;
+        auto const rhs = Monad<Parser>::return_ | a;
         return lhs <triPlus> rhs;
     };
-    return p >>= rest;
+    return toTEParser || (p >>= rest);
+}
+
+constexpr auto chainl1 = toGFunc<2> | [](auto p, auto op)
+{
+    return chainl1Impl(p, op);
 };
 
-constexpr auto chainl = toGFunc<2> | [](auto p, auto op, auto a)
+constexpr auto chainl = toGFunc<3> | [](auto p, auto op, auto a)
 {
     return (p <chainl1> op) <triPlus> (Monad<Parser>::return_ | a);
 };
@@ -1522,14 +1528,87 @@ enum class Op
     kDIV
 };
 
-auto const addOp = ((symb | "+") >> (return_ | Op::kADD)) <triPlus> ((symb | "-") >> (return_ | Op::kSUB));
-auto const mulOp = ((symb | "*") >> (return_ | Op::kMUL)) <triPlus> ((symb | "/") >> (return_ | Op::kDIV));
+class OpFunc
+{
+    Op mOp;
+public:
+    constexpr OpFunc()
+    : mOp{}
+    {}
+    constexpr OpFunc(Op op)
+    : mOp{op}
+    {}
+    template <typename T>
+    constexpr auto operator()(T x, T y) const
+    {
+        switch (mOp)
+        {
+            case Op::kADD: return x + y;
+            case Op::kSUB: return x - y;
+            case Op::kMUL: return x * y;
+            case Op::kDIV: return x / y;
+        }
+        return 0;
+    }
+};
+
+namespace op
+{
+constexpr auto add = OpFunc{Op::kADD};
+constexpr auto sub = OpFunc{Op::kSUB};
+constexpr auto mul = OpFunc{Op::kMUL};
+constexpr auto div = OpFunc{Op::kDIV};
+
+auto const addOp = ((symb | "+") >> (return_ | add)) <triPlus> ((symb | "-") >> (return_ | sub));
+auto const mulOp = ((symb | "*") >> (return_ | mul)) <triPlus> ((symb | "/") >> (return_ | div));
+} // namespace op
+
+using op::addOp;
+using op::mulOp;
+
+constexpr auto isDigit = toFunc<> | [](char x)
+{
+    return isdigit(x);
+};
+
+extern const TEParser<int> expr;
+
+constexpr auto digit = (token || sat | isDigit)
+                    >>= [](char x) { return
+                    return_ | (x - '0');
+                };
+
+// const auto factor =
+//     digit <triPlus>
+//         ((symb | "("s) >>
+//             expr >>= [](auto n){ return
+//                 (symb | ")"s) >>
+//                     (return_ | n);
+//     });
+
+// constexpr auto term = factor <chainl1> mulOp;
+
+// const TEParser<int> expr = toTEParser || term <chainl1> addOp;
 
 TEST(Parser, ops)
 {
     auto const result = apply || addOp || " +  * /-";
-    EXPECT_EQ(std::get<0>(result.at(0)), Op::kADD);
+    EXPECT_EQ(std::get<0>(result.at(0))(1, 2), 3);
 
     auto const result2 = apply || mulOp || "   * /-";
-    EXPECT_EQ(std::get<0>(result2.at(0)), Op::kMUL);
+    EXPECT_EQ(std::get<0>(result2.at(0))(1, 2), 2);
+}
+
+TEST(Parser, digit)
+{
+    auto const result = apply || many | digit || " 1  2 34";
+    auto const expected = std::vector{1, 2, 3, 4};
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
 }
+
+// TEST(Parser, factor)
+// {
+//     auto const result = apply || many | digit || " 1  2 34";
+//     auto const expected = std::vector{1, 2, 3, 4};
+//     EXPECT_EQ(std::get<0>(result.at(0)), expected);
+// }

From 2588b415838207f5247938a9f6980bf6f9efd265 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 22:59:37 +0800
Subject: [PATCH 09/16] Fix chainl1

---
 include/hspp.h     |  4 +++
 test/hspp/test.cpp | 69 ++++++++++++++++++++++++++--------------------
 2 files changed, 43 insertions(+), 30 deletions(-)

diff --git a/include/hspp.h b/include/hspp.h
index a0d7483..fa72312 100644
--- a/include/hspp.h
+++ b/include/hspp.h
@@ -300,6 +300,10 @@ class GenericFunction : public CallViaPipe<GenericFunction<nbArgs, Repr>>
 {
     static_assert(nbArgs > 0);
 public:
+    constexpr GenericFunction()
+    : mFunc{}
+    {
+    }
     constexpr GenericFunction(Repr func)
     : mFunc{std::move(func)}
     {
diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index a687ef3..282fb42 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1395,13 +1395,13 @@ constexpr auto chainl1Impl(Parser<A, Repr> p, Op op)
         auto const lhs =
             op >>= [&](auto f) { return
                 p >>= [&](auto b) { return
-                    Monad<Parser>::return_ || self(f | a | b);
+                    self(f | a | b);
                 };
             };
         auto const rhs = Monad<Parser>::return_ | a;
-        return lhs <triPlus> rhs;
+        return toTEParser || (lhs <triPlus> rhs);
     };
-    return toTEParser || (p >>= rest);
+    return (p >>= rest);
 }
 
 constexpr auto chainl1 = toGFunc<2> | [](auto p, auto op)
@@ -1486,12 +1486,6 @@ TEST(Parser, seqBy)
 //     EXPECT_EQ(std::get<0>(result.at(0)), expected);
 }
 
-TEST(Parser, chainl1)
-{
-    (void)chainl1;
-    (void)chainl;
-}
-
 TEST(Parser, space)
 {
     auto const result = runParser || space || "  12123";
@@ -1554,10 +1548,10 @@ class OpFunc
 
 namespace op
 {
-constexpr auto add = OpFunc{Op::kADD};
-constexpr auto sub = OpFunc{Op::kSUB};
-constexpr auto mul = OpFunc{Op::kMUL};
-constexpr auto div = OpFunc{Op::kDIV};
+constexpr auto add = toGFunc<2> | OpFunc{Op::kADD};
+constexpr auto sub = toGFunc<2> | OpFunc{Op::kSUB};
+constexpr auto mul = toGFunc<2> | OpFunc{Op::kMUL};
+constexpr auto div = toGFunc<2> | OpFunc{Op::kDIV};
 
 auto const addOp = ((symb | "+") >> (return_ | add)) <triPlus> ((symb | "-") >> (return_ | sub));
 auto const mulOp = ((symb | "*") >> (return_ | mul)) <triPlus> ((symb | "/") >> (return_ | div));
@@ -1578,25 +1572,24 @@ constexpr auto digit = (token || sat | isDigit)
                     return_ | (x - '0');
                 };
 
-// const auto factor =
-//     digit <triPlus>
-//         ((symb | "("s) >>
-//             expr >>= [](auto n){ return
-//                 (symb | ")"s) >>
-//                     (return_ | n);
-//     });
+const auto factor =
+    digit <triPlus>
+        (((symb | "("s) >> expr) >>= [](auto n){ return
+                (symb | ")"s) >>
+                    (return_ | n);
+    });
 
-// constexpr auto term = factor <chainl1> mulOp;
+const auto term = factor <chainl1> mulOp;
 
-// const TEParser<int> expr = toTEParser || term <chainl1> addOp;
+const TEParser<int> expr = toTEParser || (term <chainl1> addOp);
 
 TEST(Parser, ops)
 {
     auto const result = apply || addOp || " +  * /-";
-    EXPECT_EQ(std::get<0>(result.at(0))(1, 2), 3);
+    EXPECT_EQ(std::get<0>(result.at(0))| 1 | 2, 3);
 
     auto const result2 = apply || mulOp || "   * /-";
-    EXPECT_EQ(std::get<0>(result2.at(0))(1, 2), 2);
+    EXPECT_EQ(std::get<0>(result2.at(0))|1 | 2, 2);
 }
 
 TEST(Parser, digit)
@@ -1606,9 +1599,25 @@ TEST(Parser, digit)
     EXPECT_EQ(std::get<0>(result.at(0)), expected);
 }
 
-// TEST(Parser, factor)
-// {
-//     auto const result = apply || many | digit || " 1  2 34";
-//     auto const expected = std::vector{1, 2, 3, 4};
-//     EXPECT_EQ(std::get<0>(result.at(0)), expected);
-// }
+TEST(Parser, chainl1)
+{
+    auto const p = digit <chainl1> addOp;
+    auto const result = runParser | p | "1 + 2";
+    auto const expected = 3;
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
+    (void)chainl;
+}
+
+TEST(Parser, factor)
+{
+    auto const result = apply || many | digit || " 1  2 34";
+    auto const expected = std::vector{1, 2, 3, 4};
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
+}
+
+TEST(Parser, expr)
+{
+    auto const result = apply | expr | "1 - 2 * 3 + 4";
+    auto const expected = -1;
+    EXPECT_EQ(std::get<0>(result.at(0)), expected);
+}
\ No newline at end of file

From a4ce705a99f9532283e8a24741294e232af023ed Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 23:05:40 +0800
Subject: [PATCH 10/16] Fix triPlus

---
 include/hspp.h     | 11 ++++-------
 test/hspp/test.cpp |  3 ---
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/include/hspp.h b/include/hspp.h
index fa72312..a6f2e8e 100644
--- a/include/hspp.h
+++ b/include/hspp.h
@@ -300,10 +300,6 @@ class GenericFunction : public CallViaPipe<GenericFunction<nbArgs, Repr>>
 {
     static_assert(nbArgs > 0);
 public:
-    constexpr GenericFunction()
-    : mFunc{}
-    {
-    }
     constexpr GenericFunction(Repr func)
     : mFunc{std::move(func)}
     {
@@ -3229,13 +3225,14 @@ constexpr auto triPlus = toGFunc<2> | [](auto p, auto q)
 {
     return data::toParser <o> data::toFunc<> | [=](std::string cs)
     {
-        auto tmp = data::runParser | (p <mplus> q) | cs;
+        auto const tmp = data::runParser | (p <mplus> q) | cs;
         if (tmp.empty())
         {
             return tmp;
         }
-        tmp.resize(1);
-        return tmp;
+        std::remove_const_t<decltype(tmp)> tmp2;
+        tmp2.push_back(tmp.front());
+        return tmp2;
     };
 };
 } // namespace hspp
diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index 282fb42..c306923 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1526,9 +1526,6 @@ class OpFunc
 {
     Op mOp;
 public:
-    constexpr OpFunc()
-    : mOp{}
-    {}
     constexpr OpFunc(Op op)
     : mOp{op}
     {}

From b51f0daa1a266364960defea15bd8099e568594c Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 23:11:10 +0800
Subject: [PATCH 11/16] Fix tests.

---
 test/hspp/test.cpp | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index c306923..2fea2fd 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1393,8 +1393,8 @@ constexpr auto chainl1Impl(Parser<A, Repr> p, Op op)
     auto const rest = toGFunc<1> | yCombinator | [=](auto const& self, auto a) -> TEParser<A>
     {
         auto const lhs =
-            op >>= [&](auto f) { return
-                p >>= [&](auto b) { return
+            op >>= [=](auto f) { return
+                p >>= [=](auto b) { return
                     self(f | a | b);
                 };
             };
@@ -1539,7 +1539,7 @@ class OpFunc
             case Op::kMUL: return x * y;
             case Op::kDIV: return x / y;
         }
-        return 0;
+        throw std::runtime_error{"Never reach here!"};
     }
 };
 
@@ -1550,6 +1550,11 @@ constexpr auto sub = toGFunc<2> | OpFunc{Op::kSUB};
 constexpr auto mul = toGFunc<2> | OpFunc{Op::kMUL};
 constexpr auto div = toGFunc<2> | OpFunc{Op::kDIV};
 
+static_assert((add | 1 | 2) == 3);
+static_assert((sub | 1 | 2) == -1);
+static_assert((mul | 1 | 2) == 2);
+static_assert((div | 4 | 2) == 2);
+
 auto const addOp = ((symb | "+") >> (return_ | add)) <triPlus> ((symb | "-") >> (return_ | sub));
 auto const mulOp = ((symb | "*") >> (return_ | mul)) <triPlus> ((symb | "/") >> (return_ | div));
 } // namespace op

From b003c49828cfac73bddcacb77cf42efd8a2cdeaa Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 23:21:59 +0800
Subject: [PATCH 12/16] Fix gcc.

---
 test/hspp/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/hspp/test.cpp b/test/hspp/test.cpp
index 2fea2fd..7b139d1 100644
--- a/test/hspp/test.cpp
+++ b/test/hspp/test.cpp
@@ -1332,7 +1332,7 @@ auto stringImpl(std::string const& cs)
     -> Parser<std::string, StringParser>
 {
     return toParser || toFunc<> | StringParser{cs};
-};
+}
 
 constexpr auto string = toFunc<> || [](std::string const& cs)
 {

From 6d0dc6d2e5c1e49a9b38c19489281f8955d9d10d Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Sun, 19 Jun 2022 23:58:41 +0800
Subject: [PATCH 13/16] Fix win.

---
 include/hspp.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/hspp.h b/include/hspp.h
index a6f2e8e..0611fb4 100644
--- a/include/hspp.h
+++ b/include/hspp.h
@@ -21,6 +21,7 @@
 #include <forward_list>
 #include <list>
 #include <vector>
+#include <tuple>
 
 namespace hspp
 {

From 12464254a64ebbd7c139e85b23e2d910c830e318 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Mon, 20 Jun 2022 00:04:43 +0800
Subject: [PATCH 14/16] Fix win.

---
 include/hspp.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/hspp.h b/include/hspp.h
index 0611fb4..efe6075 100644
--- a/include/hspp.h
+++ b/include/hspp.h
@@ -22,6 +22,7 @@
 #include <list>
 #include <vector>
 #include <tuple>
+#include <type_traits>
 
 namespace hspp
 {

From 7b19bcba9e06aff75440b379bd59976af05e6033 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Mon, 20 Jun 2022 00:11:15 +0800
Subject: [PATCH 15/16] Fix win.

---
 include/hspp.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/hspp.h b/include/hspp.h
index efe6075..680c1be 100644
--- a/include/hspp.h
+++ b/include/hspp.h
@@ -3091,11 +3091,11 @@ class Traversable<std::tuple, Args...> : public TraversableBase<std::tuple, Args
     constexpr static auto traverse = toGFunc<2>([](auto&& f, auto&& in)
     {
         constexpr auto sizeMinusOne = std::tuple_size_v<std::decay_t<decltype(in)>> - 1;
-        auto const func = toGFunc<1>([&](auto&& lastElem)
+        auto last = std::get<sizeMinusOne>(in);
+        auto const func = toGFunc<1>([in=std::move(in), sizeMinusOne](auto&& lastElem)
         {
             return std::tuple_cat(subtuple<0, sizeMinusOne>(std::move(in)), std::make_tuple(lastElem));
         });
-        auto const& last = std::get<sizeMinusOne>(in);
         return func <fmap> (f | last);
     });
 };

From 12438df3ef1d8ac2d49c2d39dc64b9a3b5298544 Mon Sep 17 00:00:00 2001
From: Bowen Fu <missing>
Date: Mon, 20 Jun 2022 00:12:19 +0800
Subject: [PATCH 16/16] Fix win.

---
 include/hspp.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/hspp.h b/include/hspp.h
index 680c1be..4702c82 100644
--- a/include/hspp.h
+++ b/include/hspp.h
@@ -3092,7 +3092,7 @@ class Traversable<std::tuple, Args...> : public TraversableBase<std::tuple, Args
     {
         constexpr auto sizeMinusOne = std::tuple_size_v<std::decay_t<decltype(in)>> - 1;
         auto last = std::get<sizeMinusOne>(in);
-        auto const func = toGFunc<1>([in=std::move(in), sizeMinusOne](auto&& lastElem)
+        auto const func = toGFunc<1>([in=std::move(in)](auto&& lastElem)
         {
             return std::tuple_cat(subtuple<0, sizeMinusOne>(std::move(in)), std::make_tuple(lastElem));
         });