diff --git a/Main.hs b/Main.hs
--- a/Main.hs
+++ b/Main.hs
@@ -1,19 +1,22 @@
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE OverloadedStrings #-}
 
 import           Control.Applicative
+import           Control.Category.Structures
 import           Control.Lens.Cons
 import           Control.Lens.SemiIso
 import           Control.Lens.TH
+import           Control.SIArrow
 import qualified Data.Attoparsec.Text.Lazy as AP
 import           Data.Char
 import           Data.Scientific (Scientific)
-import           Data.SemiIsoFunctor
-import           Data.Syntax (Syntax)
+import           Data.Syntax (Seq)
 import qualified Data.Syntax as S
 import qualified Data.Syntax.Attoparsec.Text.Lazy as S
-import           Data.Syntax.Char (SyntaxChar)
+import           Data.Syntax.Char (SyntaxChar, SyntaxText)
 import qualified Data.Syntax.Char as S
 import qualified Data.Syntax.Combinator as S
 import qualified Data.Syntax.Printer.Text as S
@@ -39,30 +42,30 @@
 $(makePrisms ''AST)
 
 -- | A variable name.
-name :: Syntax syn Text => syn Text
+name :: SyntaxText syn => syn () Text
 name = _Cons /$/ S.satisfy isAlpha /*/ S.takeWhile isAlphaNum
 
 -- | A quoted string.
-quoted :: SyntaxChar syn seq => syn seq
+quoted :: SyntaxChar syn => syn () (Seq syn)
 quoted = S.char '"' */ S.takeTill (=='"') /* S.char '"'
 
 -- | Encloses a symbol in parentheses.
-parens :: SyntaxChar syn seq => syn a -> syn a
+parens :: SyntaxChar syn => syn () a -> syn () a
 parens m = S.char '(' */ S.spaces_ */ m /* S.spaces_ /* S.char ')'
 
 -- | A literal.
-literal :: SyntaxChar syn Text => syn Literal
+literal :: SyntaxText syn => syn () Literal
 literal =  _LitNum /$/ S.scientific
-       /|/ _LitStr /$/ quoted
+       /+/ _LitStr /$/ quoted
 
 -- | An atom is a variable, literal or an expression in parentheses.
-atom :: SyntaxChar syn Text => syn AST
+atom :: SyntaxText syn => syn () AST
 atom =  _Lit /$/ literal
-    /|/ _Var /$/ name
-    /|/ parens expr
+    /+/ _Var /$/ name
+    /+/ parens expr
 
 -- | Parses a list of atoms and folds them with the _App prism.
-apps :: SyntaxChar syn Text => syn AST
+apps :: SyntaxText syn => syn () AST
 apps = bifoldl1 _App /$/ S.sepBy1 atom S.spaces1
 
 -- | An expression of our lambda calculus.
@@ -70,20 +73,20 @@
 -- Thanks to 'tuple-morph' we don't have to worry about /* and */ here.
 -- Tuples are reassociated and units are removed by the 'morphed'
 -- isomorphism (applied in /$~ operator).
-expr :: SyntaxChar syn Text => syn AST
+expr :: SyntaxText syn => syn () AST
 expr =  _Abs /$~ S.char '\\'    /*/ S.spaces_
              /*/ name           /*/ S.spaces
              /*/ S.string "->"  /*/ S.spaces
              /*/ expr
 
-    /|/ _Let /$~ S.string "let" /*/ S.spaces1
+    /+/ _Let /$~ S.string "let" /*/ S.spaces1
              /*/ name           /*/ S.spaces
              /*/ S.char '='     /*/ S.spaces
              /*/ expr           /*/ S.spaces1
              /*/ S.string "in"  /*/ S.spaces1
              /*/ expr
 
-    /|/ apps
+    /+/ apps
 
 main :: IO ()
 main = do
@@ -91,7 +94,7 @@
     t <- T.getContents
 
     -- Try to parse it.
-    case AP.parse (S.getParser expr <* AP.skipSpace <* AP.endOfInput) t of
+    case AP.parse (S.getParser_ expr <* AP.skipSpace <* AP.endOfInput) t of
       AP.Fail _ _ err  -> putStrLn err
       AP.Done _ ast -> do
           -- If parsing succeeded print the AST.
@@ -99,7 +102,7 @@
 
           -- Try to pretty print it.
           -- (Printing cannot really fail in this example)
-          case S.runPrinter expr ast of
+          case S.runPrinter_ expr ast of
             Left err  -> putStrLn err
             Right bld -> T.putStrLn (T.toLazyText bld)
 
diff --git a/syntax-example.cabal b/syntax-example.cabal
--- a/syntax-example.cabal
+++ b/syntax-example.cabal
@@ -1,18 +1,18 @@
 name:                syntax-example
-version:             0.4.0.0
+version:             1.0.0.0
 synopsis:            Example application using syntax, a library for abstract syntax descriptions.
 description:
   Example application using syntax, a library for abstract syntax descriptions.
   .
   The code:
   .
-  * <https://github.com/Pawel834/syntax-example/blob/master/Main.hs Main.hs>
+  * <https://github.com/Pawel834/syntax-example/blob/83c283823749038db3d21aaf99105f456e25bac7/Main.hs Main.hs>
   .
   Example input:
   .
   > (\f->
   > (\x
-  >      -> f     ((x) x)) (\x 
+  >      -> f     ((x) x)) (\x
   > -> f  (x x)
   > )
   > (\x -> "test")
@@ -38,7 +38,7 @@
 
 executable syntax-example
   main-is:             Main.hs
-  build-depends:       base >= 4 && < 5, lens, semi-iso >= 0.4,
-                       syntax >= 0.2, syntax-attoparsec >= 0.2, syntax-printer,
+  build-depends:       base >= 4 && < 5, lens, semi-iso >= 1,
+                       syntax >= 1, syntax-attoparsec >= 1, syntax-printer >= 1,
                        attoparsec, text, scientific >= 0.3
   default-language:    Haskell2010