module Funcons.Operations (
  module Funcons.Operations.Atoms,
  module Funcons.Operations.ADTs,
  module Funcons.Operations.Expr,
  module Funcons.Operations.Values,
  module Funcons.Operations.Eval,
  module Funcons.Operations.Lists,
  module Funcons.Operations.Tuples,
  module Funcons.Operations.Booleans,
  module Funcons.Operations.Optionals,
  module Funcons.Operations.Types,
  module Funcons.Operations.NonGroundValues,
  module Funcons.Operations.Integers,
  module Funcons.Operations.Floats,
  module Funcons.Operations.Strings,
--  module Funcons.Operations.Rationals,
  module Funcons.Operations.Graphs,
  module Funcons.Operations.Sets,
  module Funcons.Operations.Multisets,
  module Funcons.Operations.Bits,
  module Funcons.Operations.Characters,
  module Funcons.Operations.Maps,
  libApp, libAppWith, libFromList, libUnite, Funcons.Operations.library, Library
  ) where

import Funcons.Operations.Expr 
import Funcons.Operations.Libraries 
import Funcons.Operations.Values hiding (showArgs, set_)
import Funcons.Operations.Eval hiding (showArgs)
import Funcons.Operations.Atoms hiding (library)
import qualified Funcons.Operations.Atoms (library)
import Funcons.Operations.Booleans hiding (library)
import qualified Funcons.Operations.Booleans (library)
import Funcons.Operations.Optionals hiding (library)
import qualified Funcons.Operations.Optionals (library)
import Funcons.Operations.Lists hiding (library)
import qualified Funcons.Operations.Lists (library)
import Funcons.Operations.Tuples hiding (library)
import qualified Funcons.Operations.Tuples (library)
import Funcons.Operations.Types hiding (library)
import qualified Funcons.Operations.Types (library)
import Funcons.Operations.NonGroundValues hiding (library, isGround)
import qualified Funcons.Operations.NonGroundValues (library)
import Funcons.Operations.Integers hiding (isInt, unInt, library)
import qualified Funcons.Operations.Integers (library)
import Funcons.Operations.Floats hiding (isInt, unInt, library)
import qualified Funcons.Operations.Floats (library)
import Funcons.Operations.Strings hiding (library)
import qualified Funcons.Operations.Strings (library)
--import Funcons.Operations.Rationals hiding (library)
--import qualified Funcons.Operations.Rationals (library)
import Funcons.Operations.Graphs hiding (library)
import qualified Funcons.Operations.Graphs (library)
import Funcons.Operations.Sets hiding (library, sets)
import qualified Funcons.Operations.Sets (library)
import Funcons.Operations.Multisets hiding (library, multisets)
import qualified Funcons.Operations.Multisets (library)
import Funcons.Operations.Bits hiding (library)
import qualified Funcons.Operations.Bits (library)
import Funcons.Operations.Characters hiding (library)
import qualified Funcons.Operations.Characters (library)
import Funcons.Operations.Maps hiding (library, maps)
import qualified Funcons.Operations.Maps (library)
import Funcons.Operations.ADTs hiding (library)
import qualified Funcons.Operations.ADTs

library :: (HasValues t, Ord t) => Library t
library :: Library t
library = [Library t] -> Library t
forall t. [Library t] -> Library t
libUnite [
    Library t
forall t. (HasValues t, Eq t) => Library t
Funcons.Operations.Atoms.library
  , Library t
forall t. (HasValues t, Ord t) => Library t
Funcons.Operations.ADTs.library
  , Library t
forall t. (HasValues t, Eq t) => Library t
Funcons.Operations.Booleans.library
  , Library t
forall t. (HasValues t, Eq t) => Library t
Funcons.Operations.Optionals.library
  , Library t
forall t. HasValues t => Library t
Funcons.Operations.Lists.library
  , Library t
forall t. HasValues t => Library t
Funcons.Operations.Tuples.library
  , Library t
forall t. (HasValues t, Ord t) => Library t
Funcons.Operations.Types.library
  , Library t
forall t. (HasValues t, Eq t) => Library t
Funcons.Operations.NonGroundValues.library
  , Library t
forall t. HasValues t => Library t
Funcons.Operations.Integers.library
  , Library t
forall t. HasValues t => Library t
Funcons.Operations.Floats.library
  , Library t
forall t. HasValues t => Library t
Funcons.Operations.Strings.library
--  , Funcons.Operations.Rationals.library
  , Library t
forall t. (HasValues t, Ord t) => Library t
Funcons.Operations.Graphs.library
  , Library t
forall t. (HasValues t, Ord t) => Library t
Funcons.Operations.Sets.library
  , Library t
forall t. (HasValues t, Ord t) => Library t
Funcons.Operations.Multisets.library
  , Library t
forall t. (HasValues t, Ord t) => Library t
Funcons.Operations.Bits.library
  , Library t
forall t. (HasValues t, Ord t) => Library t
Funcons.Operations.Characters.library
  , Library t
forall t. (HasValues t, Ord t) => Library t
Funcons.Operations.Maps.library
  ]

libApp :: (HasValues t, Ord t) => OP -> [OpExpr t] -> Maybe (OpExpr t)
libApp :: OP -> [OpExpr t] -> Maybe (OpExpr t)
libApp = Library t -> OP -> [OpExpr t] -> Maybe (OpExpr t)
forall t.
(HasValues t, Ord t) =>
Library t -> OP -> [OpExpr t] -> Maybe (OpExpr t)
libAppWith Library t
forall t. (HasValues t, Ord t) => Library t
library

libAppWith :: (HasValues t, Ord t) => Library t -> OP -> [OpExpr t] -> Maybe (OpExpr t)
libAppWith :: Library t -> OP -> [OpExpr t] -> Maybe (OpExpr t)
libAppWith Library t
lib OP
op [OpExpr t]
args = do 
  ValueOp t
valop <- OP -> Library t -> Maybe (ValueOp t)
forall t. OP -> Library t -> Maybe (ValueOp t)
libLookup OP
op Library t
lib
  case ([OpExpr t]
args, ValueOp t
valop) of
    ([], NullaryExpr OpExpr t
op)      -> OpExpr t -> Maybe (OpExpr t)
forall a. a -> Maybe a
Just OpExpr t
op
    ([OpExpr t
x], UnaryExpr UnaryExpr t
op)       -> OpExpr t -> Maybe (OpExpr t)
forall a. a -> Maybe a
Just (UnaryExpr t
op OpExpr t
x)
    ([OpExpr t
x,OpExpr t
y], BinaryExpr BinaryExpr t
op)    -> OpExpr t -> Maybe (OpExpr t)
forall a. a -> Maybe a
Just (BinaryExpr t
op OpExpr t
x OpExpr t
y)
    ([OpExpr t
x,OpExpr t
y,OpExpr t
z], TernaryExpr TernaryExpr t
op) -> OpExpr t -> Maybe (OpExpr t)
forall a. a -> Maybe a
Just (TernaryExpr t
op OpExpr t
x OpExpr t
y OpExpr t
z)
    ([OpExpr t]
_, NaryExpr NaryExpr t
op)          -> OpExpr t -> Maybe (OpExpr t)
forall a. a -> Maybe a
Just (NaryExpr t
op [OpExpr t]
args)
    ([OpExpr t], ValueOp t)
_                         -> Maybe (OpExpr t)
forall a. Maybe a
Nothing