Example of https://github.com/seliopou/typo output!

in.scm

(+ 1 2)

out.hs

-------------------------------------------------------------------------------
-- BEGIN PRELUDE --------------------------------------------------------------
-------------------------------------------------------------------------------

{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}
{-# LANGUAGE OverlappingInstances #-}

undefined = undefined

data True
data False

true = undefined :: True
false = undefined :: False

class And a b c | a b -> c where
  and :: a -> b -> c
  and = undefined

class Or a b c | a b -> c where
  or :: a -> b -> c
  or = undefined

class Imp a b c | a b -> c where
  imp :: n -> b -> c
  imp = undefined

class Cond c t f r | c t f -> r where
  cond :: c -> t -> f -> r
  cond = undefined

instance And True True True
instance And True False False
instance And False True False
instance And False False False

instance Or True True True
instance Or True False True
instance Or False True True
instance Or False False False

instance Imp True True True
instance Imp True False False
instance Imp False True True
instance Imp False False True

instance Cond True t f t
instance Cond False t f f

data Z
data S n

data Neg n

data LT
data EQ
data GT

class Compare n m c | n m -> c where
  compare :: n -> m -> c
  compare = undefined

instance Compare Z       Z       EQ
instance Compare Z       (S m)   LT
instance Compare (S n)   Z       GT
instance Compare (Neg n) Z       LT
instance Compare Z       (Neg m) GT
instance Compare (Neg n) (S m)   LT
instance Compare (S n)   (Neg m) GT
instance Compare m n c => Compare (Neg n) (Neg m) c
instance Compare n m c => Compare (S n)   (S m)   c

class Eq n m b | n m -> b where
  eq :: n -> m -> b
  eq = undefined

class Eq' n m c b | n m c -> b where
  eq' :: n -> m -> c -> b
  eq' = undefined

class Lt n m b | n m -> b where
  lt :: n -> m -> b
  lt = undefined

class Lt' n m c b | n m c -> b where
  lt' :: n -> m -> c -> b
  lt' = undefined

instance Eq' n m LT False
instance Eq' n m EQ True
instance Eq' n m GT False

instance (Compare n m c, Eq' n m c b) => Eq n m b

instance Lt' n m LT True
instance Lt' n m EQ False
instance Lt' n m GT False

instance (Compare n m c, Lt' n m c b) => Lt n m b

class Add n m k | n m -> k where
  add :: n -> m -> k
  add = undefined

instance Add Z Z Z
instance Add n Z n
instance Add Z m m

instance Add n m r => Add (Neg n) (Neg m) (Neg r)
instance Sub m n r => Add (Neg n) m       r
instance Sub n m r => Add n       (Neg m) r
instance Add n m r => Add (S n)   (S m)   (S (S r))

class Sub n m k | n m -> k where
  sub :: n -> m -> k
  sub = undefined

instance Sub Z Z       Z
instance Sub n Z       n
instance Sub Z (Neg m) m
instance Sub Z (S m)   (Neg (S m))

instance Sub m n r => Sub (Neg n) (Neg m) r
instance Add n m r => Sub (Neg n) (S m)   (Neg (S r))
instance Add n m r => Sub (S n)   (Neg m) (S r)
instance Sub n m r => Sub (S n)   (S m)   r

class Mul n m k | n m -> k where
  mul :: n -> m -> k
  mul = undefined

instance Mul Z Z Z
instance Mul n Z Z
instance Mul Z m Z

instance Mul n     m     r => Mul (Neg n) (Neg m) r
instance Mul (S n) m     r => Mul (S n)   (Neg m) (Neg r)
instance Mul n     (S m) r => Mul (Neg n) (S m)   (Neg r)
instance (Mul n m k, Add n k k', Add m k' r) => Mul (S n) (S m) (S r)

class DivRem n m q r | n m -> q r where
  divRem :: n -> m -> (q, r)
  divRem = undefined

class DivRemBranch0 b n m q r | b n m -> q r where
  divRemBranch0 :: b -> n -> m -> (q, r)
  divRemBranch0 = undefined

instance DivRemBranch0 LT n m Z n
instance DivRemBranch0 EQ n m (S Z) Z
instance (Sub n m n', DivRem n' m q r) => DivRemBranch0 GT n m (S q) r

instance (Compare n m c, DivRemBranch0 c n m q r) => DivRem n m q r

class Div n m k | n m -> k where
  div :: n -> m -> k
  div = undefined

class Rem n m r | n m -> r where
  rem :: n -> m -> r
  rem = undefined

instance DivRem n m q r => Div n m q
instance DivRem n m q r => Rem n m r

-------------------------------------------------------------------------------
-- END PRELUDE ----------------------------------------------------------------
-------------------------------------------------------------------------------

result = add (undefined :: S Z) (undefined :: S (S Z))