This is the documentation for the Scala TPTP parser used, e.g., by the [[https://github.com/leoprover/Leo-III Leo-III prover]].

== Package structure ==

The [[leo]] package contains two sub-packages as follows:

  - [[leo.datastructures `leo.datastructures`]] contains the [[leo.datastructures.TPTP]] object
    that bundles the different abstract syntax tree (AST) representations for the different TPTP
    language dialects, including ...
    - [[leo.datastructures.TPTP.THF `leo.datastructures.TPTP.THF`]] - Higher-order formulas (THF)
    - [[leo.datastructures.TPTP.TFF `leo.datastructures.TPTP.TFF`]] - Typed first-order formulas (TFF)
    - [[leo.datastructures.TPTP.FOF `leo.datastructures.TPTP.FOF`]] - Untyped first-order formulas (FOF)
    - [[leo.datastructures.TPTP.TCF `leo.datastructures.TPTP.TCF`]] - Typed clausal form (TCF)
    - [[leo.datastructures.TPTP.CNF `leo.datastructures.TPTP.CNF`]] - Untyped clausal form (CNF)
  - [[leo.modules.input  `leo.modules.input` ]] - the parser itself.

== Usage (in short) ==

The [[leo.modules.input.TPTPParser]] offers several parsing methods:
  - [[leo.modules.input.TPTPParser.problem]] - for a whole TPTP problem
  - [[leo.modules.input.TPTPParser.annotated]] - for an annotated TPTP formula (specialized methods
    for the individual dialects exist).
  - [[leo.modules.input.TPTPParser.thf]] - for a plain THF formula (without annotations)
  - [[leo.modules.input.TPTPParser.tff]] - for a plain TFF formula (without annotations)
  - ... etc.

== Exemplary use case ==

{{{
  import leo.modules.input.{TPTPParser => Parser}
  import TPTPParser.TPTPParseException
  import leo.datastructures.TPTP.THF

  try {
   val result = Parser.problem(io.Source.fromFile("/path/to/file"))
   println(s"Parsed ${result.formulas.size} formulae and ${result.includes.size} include statements.")
   // ...
   val annotatedFormula = Parser.annotatedTHF("thf(f, axiom, ![X:$i]: (p @ X)).")
   println(s"${annotatedFormula.name} is an ${annotatedFormula.role}.")
   // ...
   val formula = Parser.thf("![X:$i]: (p @ X)")
   formula match {
     case THF.FunctionTerm(f, args) => // ...
     case THF.QuantifiedFormula(quantifier, variableList, body) => // ...
     case THF.Variable(name) => // ...
     case THF.UnaryFormula(connective, body) => // ...
     case THF.BinaryFormula(connective, left, right) => // ...
     case THF.Tuple(elements) => // ...
     case THF.ConditionalTerm(condition, thn, els) => // ...
     case THF.LetTerm(typing, binding, body) => // ...
     case THF.DefinedTH1ConstantTerm(constant) => // ...
     case THF.ConnectiveTerm(conn) => // ...
     case THF.DistinctObject(name) => // ...
     case THF.NumberTerm(value) => // ...
   }
   // ...
  } catch {
   case e: TPTPParseException => println(s"Parse error at line ${e.line}:${e.offset}: ${e.getMessage}")
  }
}}}

This is the documentation for the Scala standard library.

== Package structure ==

The [[scala]] package contains core types like [[scala.Int `Int`]], [[scala.Float `Float`]], [[scala.Array `Array`]]
or [[scala.Option `Option`]] which are accessible in all Scala compilation units without explicit qualification or
imports.

Notable packages include:

  - [[scala.collection    `scala.collection`]] and its sub-packages contain Scala's collections framework
    - [[scala.collection.immutable `scala.collection.immutable`]] - Immutable, sequential data-structures such as
      [[scala.collection.immutable.Vector `Vector`]], [[scala.collection.immutable.List `List`]],
      [[scala.collection.immutable.Range `Range`]], [[scala.collection.immutable.HashMap `HashMap`]] or
      [[scala.collection.immutable.HashSet `HashSet`]]
    - [[scala.collection.mutable `scala.collection.mutable`]] - Mutable, sequential data-structures such as
      [[scala.collection.mutable.ArrayBuffer `ArrayBuffer`]],
      [[scala.collection.mutable.StringBuilder `StringBuilder`]],
      [[scala.collection.mutable.HashMap `HashMap`]] or [[scala.collection.mutable.HashSet `HashSet`]]
    - [[scala.collection.concurrent `scala.collection.concurrent`]] - Mutable, concurrent data-structures such as
      [[scala.collection.concurrent.TrieMap `TrieMap`]]
  - [[scala.concurrent    `scala.concurrent`]] - Primitives for concurrent programming such as
    [[scala.concurrent.Future `Futures`]] and [[scala.concurrent.Promise `Promises`]]
  - [[scala.io            `scala.io`]]     - Input and output operations
  - [[scala.math          `scala.math`]]   - Basic math functions and additional numeric types like
    [[scala.math.BigInt `BigInt`]] and [[scala.math.BigDecimal `BigDecimal`]]
  - [[scala.sys           `scala.sys`]]    - Interaction with other processes and the operating system
  - [[scala.util.matching `scala.util.matching`]] - [[scala.util.matching.Regex Regular expressions]]

Other packages exist.  See the complete list on the right.

Additional parts of the standard library are shipped as separate libraries. These include:

  - [[https://www.scala-lang.org/api/current/scala-reflect/scala/reflect/index.html `scala.reflect`]] - Scala's reflection API (scala-reflect.jar)
  - [[https://github.com/scala/scala-xml `scala.xml`]] - XML parsing, manipulation, and serialization (scala-xml.jar)
  - [[https://github.com/scala/scala-parallel-collections `scala.collection.parallel`]] - Parallel collections (scala-parallel-collections.jar)
  - [[https://github.com/scala/scala-parser-combinators `scala.util.parsing`]] - Parser combinators (scala-parser-combinators.jar)
  - [[https://github.com/scala/scala-swing `scala.swing`]] - A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)

== Automatic imports ==

Identifiers in the scala package and the [[scala.Predef `scala.Predef`]] object are always in scope by default.

Some of these identifiers are type aliases provided as shortcuts to commonly used classes.  For example, `List` is an alias for
[[scala.collection.immutable.List `scala.collection.immutable.List`]].

Other aliases refer to classes provided by the underlying platform.  For example, on the JVM, `String` is an alias for `java.lang.String`.
