Move to Jukebox.* hierarchy.

API.hs

@@ -1,4 +1,4 @@
-module API where
+module Jukebox.API where
 
 -- this is not actual code, it is just for writing down ideas
 

Graph.hs

@@ -1,5 +1,5 @@
 {-# LANGUAGE TemplateHaskell #-}
-module Graph where
+module Jukebox.Graph where
 
 import Data.Map as M
 import Data.Set as S

Clausify.hs → Jukebox/Clausify.hs

@@ -1,22 +1,22 @@
 {-# LANGUAGE TypeOperators, BangPatterns #-}
-module Clausify where
+module Jukebox.Clausify where
 
-import Form
-import qualified Form
-import Name
+import Jukebox.Form
+import qualified Jukebox.Form as Form
+import Jukebox.Name
 import Data.List( maximumBy, sortBy, partition )
 import Data.Ord
 import Control.Monad.Reader
 import Control.Monad.State.Strict
-import qualified Seq as S
-import Seq(Seq)
-import qualified NameMap
-import NameMap(NameMap)
-import qualified Map
+import qualified Jukebox.Seq as S
+import Jukebox.Seq(Seq)
+import qualified Jukebox.NameMap as NameMap
+import Jukebox.NameMap(NameMap)
+import qualified Jukebox.Map as Map
 import qualified Data.HashSet as Set
 import qualified Data.ByteString.Char8 as BS
-import Utils
-import Options
+import Jukebox.Utils
+import Jukebox.Options
 import Control.Applicative
 
 newtype ClausifyFlags = ClausifyFlags { splitting :: Bool } deriving Show

Form.hs → Jukebox/Form.hs

@@ -3,21 +3,21 @@
 -- "Show" instances for several of these types are found in TPTP.Print.
 
 {-# LANGUAGE DeriveDataTypeable, FlexibleContexts, Rank2Types, GADTs, TypeOperators, ScopedTypeVariables, BangPatterns, PatternGuards #-}
-module Form where
+module Jukebox.Form where
 
 import Prelude hiding (sequence, mapM)
-import qualified Seq as S
-import Seq(Seq)
+import qualified Jukebox.Seq as S
+import Jukebox.Seq(Seq)
 import Data.Hashable
-import qualified Map
-import NameMap(NameMap)
-import qualified NameMap
+import qualified Jukebox.Map as Map
+import Jukebox.NameMap(NameMap)
+import qualified Jukebox.NameMap as NameMap
 import Data.Ord
 import qualified Data.ByteString.Char8 as BS
-import Name
+import Jukebox.Name
 import Control.Monad.State.Strict hiding (sequence, mapM)
 import Data.List hiding (nub)
-import Utils
+import Jukebox.Utils
 import Data.Typeable(Typeable)
 import Data.Monoid
 import Data.Traversable

GuessModel.hs → Jukebox/GuessModel.hs

@@ -1,14 +1,14 @@
 {-# LANGUAGE GADTs, PatternGuards #-}
-module GuessModel where
+module Jukebox.GuessModel where
 
 import Control.Monad
 import qualified Data.ByteString.Char8 as BS
-import Name
-import Form
-import Clausify hiding (cnf)
-import TPTP.Print
-import TPTP.ParseSnippet
-import Utils
+import Jukebox.Name
+import Jukebox.Form
+import Jukebox.Clausify hiding (cnf)
+import Jukebox.TPTP.Print
+import Jukebox.TPTP.ParseSnippet
+import Jukebox.Utils
 
 data Universe = Peano | Trees
 

HighSat.hs → Jukebox/HighSat.hs

@@ -1,13 +1,13 @@
 {-# LANGUAGE BangPatterns, GeneralizedNewtypeDeriving #-}
-module HighSat where
+module Jukebox.HighSat where
 
 import MiniSat hiding (neg)
 import qualified MiniSat
-import qualified Seq as Seq
-import Seq(Seq, List)
-import Form(Signed(..), neg)
-import qualified Map
-import Map(Map)
+import qualified Jukebox.Seq as Seq
+import Jukebox.Seq(Seq, List)
+import Jukebox.Form(Signed(..), neg)
+import qualified Jukebox.Map as Map
+import Jukebox.Map(Map)
 import Control.Monad.State.Strict
 import Control.Monad.Reader
 import Control.Monad.Trans

InferTypes.hs → Jukebox/InferTypes.hs

@@ -1,12 +1,12 @@
 {-# LANGUAGE TypeOperators, GADTs #-}
-module InferTypes where
+module Jukebox.InferTypes where
 
 import Control.Monad
-import Form
-import Name
-import qualified NameMap
-import NameMap(NameMap)
-import UnionFind hiding (rep)
+import Jukebox.Form
+import Jukebox.Name
+import qualified Jukebox.NameMap as NameMap
+import Jukebox.NameMap(NameMap)
+import Jukebox.UnionFind hiding (rep)
 
 type Function' = Name ::: ([Type'], Type')
 type Variable' = Name ::: Type'

Map.hs → Jukebox/Map.hs

@@ -1,5 +1,5 @@
 {-# LANGUAGE NoMonomorphismRestriction #-}
-module Map where
+module Jukebox.Map where
 
 import qualified Data.HashMap.Lazy as H
 

Monotonox/Monotonicity.hs → Jukebox/Monotonox/Monotonicity.hs

@@ -1,12 +1,12 @@
 {-# LANGUAGE TypeOperators #-}
-module Monotonox.Monotonicity where
+module Jukebox.Monotonox.Monotonicity where
 
 import Prelude hiding (lookup)
-import Name
-import Form hiding (Form, clause, true, false, conj, disj)
-import HighSat
-import NameMap
-import Utils
+import Jukebox.Name
+import Jukebox.Form hiding (Form, clause, true, false, conj, disj)
+import Jukebox.HighSat
+import Jukebox.NameMap as NameMap
+import Jukebox.Utils
 import Data.Hashable
 import Control.Monad
 

Monotonox/ToFOF.hs → Jukebox/Monotonox/ToFOF.hs

@@ -1,11 +1,11 @@
 {-# LANGUAGE GADTs, PatternGuards #-}
-module Monotonox.ToFOF where
+module Jukebox.Monotonox.ToFOF where
 
-import Clausify(split, removeEquiv, run, withName)
-import Name
-import qualified NameMap
-import Form
-import Options
+import Jukebox.Clausify(split, removeEquiv, run, withName)
+import Jukebox.Name
+import qualified Jukebox.NameMap as NameMap
+import Jukebox.Form
+import Jukebox.Options
 import qualified Data.ByteString.Char8 as BS
 import Control.Monad hiding (guard)
 import Data.Monoid

Name.hs → Jukebox/Name.hs

@@ -1,5 +1,5 @@
 {-# LANGUAGE TypeOperators, GeneralizedNewtypeDeriving, FlexibleInstances, DeriveDataTypeable #-}
-module Name(
+module Jukebox.Name(
   Name, uniqueId, base,
   stringBaseName,
   unsafeMakeName,
@@ -11,8 +11,8 @@ module Name(
 
 import qualified Data.ByteString.Char8 as BS
 import Data.Hashable
-import qualified Map
-import Utils
+import qualified Jukebox.Map as Map
+import Jukebox.Utils
 import Data.List
 import Data.Ord
 import Data.Int

NameMap.hs → Jukebox/NameMap.hs

@@ -1,11 +1,11 @@
-module NameMap(NameMap, lookup, lookup_, insert, member, delete, (!), fromList, toList, singleton) where
+module Jukebox.NameMap(NameMap, lookup, lookup_, insert, member, delete, (!), fromList, toList, singleton) where
 
 import Prelude hiding (lookup)
-import Name
-import Map(Map)
-import qualified Map
+import Jukebox.Name
+import Jukebox.Map(Map)
+import qualified Jukebox.Map as Map
 import Data.Int
-import qualified Seq as S
+import qualified Jukebox.Seq as S
 
 type NameMap a = Map Int64 a
 

Options.hs → Jukebox/Options.hs

@@ -1,5 +1,5 @@
 {-# LANGUAGE FlexibleContexts #-}
-module Options where
+module Jukebox.Options where
 
 import Control.Arrow((***))
 import Control.Applicative

ProgressBar.hs → Jukebox/ProgressBar.hs

@@ -1,4 +1,4 @@
-module ProgressBar(ProgressBar(..), tickOnRead, withProgressBar) where
+module Jukebox.ProgressBar(ProgressBar(..), tickOnRead, withProgressBar) where
 
 import System.IO
 import Data.IORef

Provers/E.hs → Jukebox/Provers/E.hs

@@ -1,23 +1,23 @@
 {-# LANGUAGE GADTs #-}
-module Provers.E where
+module Jukebox.Provers.E where
 
-import Form hiding (tag, Or)
-import Name
-import Options
+import Jukebox.Form hiding (tag, Or)
+import Jukebox.Name
+import Jukebox.Options
 import Control.Applicative hiding (Const)
 import Control.Monad
-import Utils
-import TPTP.Parsec
-import TPTP.ClauseParser hiding (newFunction, Term)
-import TPTP.Print
-import TPTP.Lexer hiding (Normal, keyword, Axiom, name, Var)
+import Jukebox.Utils
+import Jukebox.TPTP.Parsec
+import Jukebox.TPTP.ClauseParser hiding (newFunction, Term)
+import Jukebox.TPTP.Print
+import Jukebox.TPTP.Lexer hiding (Normal, keyword, Axiom, name, Var)
 import Text.PrettyPrint.HughesPJ hiding (parens)
 import Data.Maybe
 import qualified Data.ByteString.Char8 as BS
 import qualified Data.ByteString.Lazy.Char8 as BSL
-import qualified Seq as S
-import qualified Map
-import Map(Map)
+import qualified Jukebox.Seq as S
+import qualified Jukebox.Map as Map
+import Jukebox.Map(Map)
 import Data.Hashable
 
 data EFlags = EFlags {
@@ -109,4 +109,4 @@ extractAnswer prob str = fromMaybe (Left status) (fmap Right answer)
           bracks (term `sepBy1` punct Comma)
           <|> return []
         lookup :: (Ord a, Hashable a) => Map BS.ByteString a -> BS.ByteString -> a
-        lookup m x = Map.findWithDefault (error "runE: result from E mentions free names") x m
+        lookup m x = Map.findWithDefault (error "runE: result from E mentions free names") x m

Sat.hs → Jukebox/Sat.hs

@@ -1,4 +1,4 @@
-module Sat
+module Jukebox.Sat
   ( Solver
   , newSolver
   , deleteSolver

Sat3.hs → Jukebox/Sat3.hs

@@ -1,6 +1,6 @@
-module Sat3 where
+module Jukebox.Sat3 where
 
-import Sat
+import Jukebox.Sat
 
 --------------------------------------------------------------------------------
 

SatEq.hs → Jukebox/SatEq.hs

@@ -1,8 +1,8 @@
-module SatEq where
+module Jukebox.SatEq where
 
-import Sat
-import Sat3
-import SatMin
+import Jukebox.Sat
+import Jukebox.Sat3
+import Jukebox.SatMin
 
 import Data.IORef
 import Data.Map as M

SatMin.hs → Jukebox/SatMin.hs

@@ -1,6 +1,6 @@
-module SatMin where
+module Jukebox.SatMin where
 
-import Sat
+import Jukebox.Sat
 
 solveLocalMin :: SatSolver s => s -> [Lit] -> [Lit] -> IO Bool
 solveLocalMin s as ms =

Seq.hs → Jukebox/Seq.hs

@@ -1,5 +1,5 @@
 -- Strict lists with efficient append.
-module Seq where
+module Jukebox.Seq where
 
 import Prelude hiding (concat, concatMap, length, mapM, mapM_)
 import Control.Monad hiding (mapM, mapM_)

TPTP/ClauseParser.hs → Jukebox/TPTP/ClauseParser.hs

@@ -1,30 +1,30 @@
 -- Parse and typecheck TPTP clauses, stopping at include-clauses.
 
 {-# LANGUAGE BangPatterns, MultiParamTypeClasses, ImplicitParams, FlexibleInstances, TypeOperators, TypeFamilies #-}
-module TPTP.ClauseParser where
+module Jukebox.TPTP.ClauseParser where
 
-import TPTP.Parsec
+import Jukebox.TPTP.Parsec
 import Control.Applicative
 import Control.Monad
 import qualified Data.ByteString.Lazy.Char8 as BSL
 import qualified Data.ByteString.Char8 as BS
-import qualified Map
-import Map(Map)
-import qualified Seq as S
-import Seq(Seq)
+import qualified Jukebox.Map as Map
+import Jukebox.Map(Map)
+import qualified Jukebox.Seq as S
+import Jukebox.Seq(Seq)
 import Data.List
-import TPTP.Print
-import Name hiding (name)
-import qualified NameMap
+import Jukebox.TPTP.Print
+import Jukebox.Name hiding (name)
+import qualified Jukebox.NameMap as NameMap
 
-import TPTP.Lexer hiding
+import Jukebox.TPTP.Lexer hiding
   (Pos, Error, Include, Var, Type, Not, ForAll,
    Exists, And, Or, Type, Apply, Implies, Follows, Xor, Nand, Nor,
    keyword, defined, kind)
-import qualified TPTP.Lexer as L
-import qualified Form
-import Form hiding (tag, kind, Axiom, Conjecture, Question, newFunction, TypeOf(..))
-import qualified Name
+import qualified Jukebox.TPTP.Lexer as L
+import qualified Jukebox.Form as Form
+import Jukebox.Form hiding (tag, kind, Axiom, Conjecture, Question, newFunction, TypeOf(..))
+import qualified Jukebox.Name as Name
 
 -- The parser monad
 

TPTP/FindFile.hs → Jukebox/TPTP/FindFile.hs

@@ -1,4 +1,4 @@
-module TPTP.FindFile where
+module Jukebox.TPTP.FindFile where
 
 import System.FilePath
 import System.Directory(doesFileExist)
@@ -7,7 +7,7 @@ import Control.Applicative
 import Control.Exception
 import Control.Monad
 import Prelude hiding (catch)
-import Options
+import Jukebox.Options
 import Data.Traversable(sequenceA)
 
 findFile :: [FilePath] -> FilePath -> IO (Maybe FilePath)
@@ -38,4 +38,4 @@ findFileFlags =
       []
       argFiles,
     io getTPTPDirs
-    ]
+    ]

TPTP/Lexer.x → Jukebox/TPTP/Lexer.x

@@ -4,7 +4,7 @@
 {
 {-# OPTIONS_GHC -O2 -fno-warn-deprecated-flags #-}
 {-# LANGUAGE BangPatterns #-}
-module TPTP.Lexer(
+module Jukebox.TPTP.Lexer(
   scan,
   Pos(..),
   Token(..),