1 files changed, 25 insertions, 47 deletions
diff --git a/Example.hs b/Example.hs
index 1811fc4..9230d97 100644
--- a/Example.hs
+++ b/Example.hs
@@ -6,54 +6,32 @@ import GHC.Generics
 import Text.Megaparsec
 import Coalpit
 
-data RecTest = RecTest { a :: Maybe Int
-                       , b :: Maybe Double
-                       , c :: Maybe Int }
-             deriving (Generic, Show)
-
-instance ArgParser RecTest
-instance ToArgs RecTest
-
-data Foo = Bar Int
-         | Baz Int
-         | Qux [Int] (Maybe Int) (Either String Int) RecTest (Maybe Double)
-  deriving (Generic, Show)
-
-instance ArgParser Foo
-instance ToArgs Foo
-
-data Wrap = Wrap { foo :: Maybe Foo, num :: Maybe Int }
-  deriving (Generic, Show)
-
-instance ArgParser Wrap
-instance ToArgs Wrap
+data FooArgs = FooArgs { arg1 :: Int
+                       , arg2 :: String
+                       } deriving (Generic, Show)
+instance ArgParser FooArgs
+instance ToArgs FooArgs
+
+data FooBar = Foo FooArgs
+            | Bar
+            deriving (Generic, Show)
+instance ArgParser FooBar
+instance ToArgs FooBar
+
+data Input = Input { something :: Maybe String
+                   , fooBar :: Maybe FooBar
+                   , fooBar2 :: FooBar
+                   } deriving (Generic, Show)
+instance ArgParser Input
+instance ToArgs Input
 
 main :: IO ()
 main = do
-  let val = Wrap (Just $ Qux [1,2,3] Nothing (Left "foo bar")
-                  (RecTest Nothing (Just 2.3) Nothing) Nothing) (Just 1)
-      a = toArgs defMod val
+  let val = Input { something = Nothing
+                  , fooBar = Just (Foo (FooArgs { arg1 = 1
+                                                , arg2 = "a string"}))
+                  , fooBar2 = Bar}
+      args = toArgs defMod val
   print val
-  print a
-  print $ parse (argParser defMod :: Parser Wrap) "test" a
-
-
-data Record = Record { maybeInt :: Maybe Int
-                     , maybeDouble :: Maybe Double
-                     , str :: String
-                     , listOfStrings :: [String]
-                     , maybeListOfNumbers :: Maybe [Int]
-                     , otherString :: String
-                     } deriving (Generic, Eq, Show)
-instance ArgParser Record
-instance ToArgs Record
-
-
-data NestedRecursiveRecord =
-  NestedRecursiveRecord { record1 :: Maybe Record
-                        , recursiveRecord :: Maybe NestedRecursiveRecord
-                        , record2 :: Maybe Record
-                        } deriving (Generic, Eq, Show)
-instance ArgParser NestedRecursiveRecord
-instance ToArgs NestedRecursiveRecord
-
+  print args
+  print $ parse (argParser defMod :: Parser Input) "test" args