+;r      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !!"""""""""""""""""""""""""""##########$$$$$%%%%% % % % % %%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)&*&+&,&-&.&/&0&1&2'3'4(5(6(7(8(9(:(;(<(=(>(?(@(A(B(C(D(E(F(G(H(I(J(K(L(M(N(O(P(Q(R(S)T)U)V*W+X+Y+Z,[,\,],^-_-`-a-b-c-d-e-f-g-h-i-j.k.l.m.n.o.p.q.r.s.t.u.v/w/x/y/z/{/|0}0~0000000000000000000000000000000001111222222222233333333333333333333333333333333333333333334455555555555555555555555555555567778888888888888 8 8 8 8 8888888888888888888 8!8"8#8$8%8&8'8(8)8*8+8,8-8.8/808182838485868788898:8;8<9=9>9?9@9A9B9C9D9E9F9G9H9I9J9K9L9M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:\:]:^:_:`:a:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z:{:|:}:~:::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;     <<<<<<<<<<<<< <!<"<#<$<%<&<'<(<)<*<+<,<-=.=/=0=1=2=3=4=5=6=7=8>9>:>;><>=>>>?>@>A>B>C>D>E>F>G>H>I>J>K>L>M>N>O>P>Q>R>S?T?U?V?W?X@Y@Z@[@\@]@^@_@`@aAbAcBdBeBfBgBhBiBjBkBlBmBnBoBpBqBBSafe rstuv rstuvSafe    Safe#       Safe57Safe57  !"#  !"#  !"# !"#None579;AT(54After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)6Similar to a union merge, but, on conflict, prefer the unmerged section (relvar, function, etc.) from the branch named as the argument.7Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.94Dynamically create a tuple from attribute names and \s.;Create attributes dynamically.?The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.@.no filesystem persistence/memory-only databaseAfsync off, not crash-safeBxfull fsync to disk (flushes kernel and physical drive buffers to ensure that the transaction is on non-volatile storage)CThe C structure represents a set of attribute names or the same set of names but inverted in the context of a relational expression. For example, if a relational expression has attributes named "a", "b", and "c", the E of ("a","c") is ("b").HOAn AtomFunction has a name, a type, and a function body to execute when called.T0Used in tuple creation when creating a relation.VAn atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.]The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.bsEvery set of modifications made to the database are atomically committed to the transaction graph as a transaction.cBEvery transaction has context-specific information attached to it.fbThe transaction graph is the global database's state which references every committed transaction.iA transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.jRestriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.sAdding an atom function should be nominally a DatabaseExpr except for the fact that it cannot be performed purely. Thus, we create the DatabaseContextIOExpr.v9Database context expressions modify the database context.Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time. I spent some time thinking about whether the VirtualDatabaseContext/Schema and DatabaseContext data constructors should be the same constructor, but that would allow relation variables to be created in a "virtual" context which would appear to defeat the isomorphisms of the contexts. It should be possible to switch to an alternative schema to view the same equivalent information without information loss. However, allowing all contexts to reference another context while maintaining its own relation variables, new types, etc. could be interesting from a security perspective. For example, if a user creates a new relvar in a virtual context, then does it necessarily appear in all linked contexts? After deliberation, I think the relvar should appear in *all* linked contexts to retain the isomorphic properties, even when the isomorphism is for a subset of the context. This hints that the IsoMorphs should allow for "fall-through"; that is, when a relvar is not defined in the virtual context (for morphing), then the lookup should fall through to the underlying context.\Every transaction has one concrete database context and any number of isomorphic subschemas.HUsed to define a data constructor in a type constructor context such as Left a | Right bTFound in data constructors and type declarations: Left (Either Int Text) | Right Int2Metadata definition for type constructors such as data Either a b.When the changeExpr returns a different result in the database context, then the reportExpr is triggered and sent asynchronously to all clients.IA relational expression represents query (read) operations on a database.1Relation variables are identified by their names.>Used to represent the number of tuples in a relation. /A tuple is a set of attributes mapped to their  values.5The relation's tuple set is the body of the relation." represent the head of a relation.;A relation's type is composed of attribute names and types.<The AttributeName is the name of an attribute in a relation.4The AtomType uniquely identifies the type of a atom.~Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.uReturn True iff the atom type argument is relation-valued. If True, this indicates that the Atom contains a relation.*Equality function for a set of attributes.)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv|{wxyz}~vwxyz{|}~sturjklmnopq ihfgcde b`a_]^  \VWXYZ[ TUSRQPOMNHIJKLCDEFG?@AB>;<=9:84567321/0*+,-.)u)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      NoneReturn the type of an . None None NonetCreate a new transaction which is identical to the original except that a new set of child transaction ids is added.Return the same transaction but referencing only the specific child transactions. This is useful when traversing a graph and returning a subgraph. This doesn't filter parent transactions because it assumes a head-to-root traversal.LRemove any child or parent transaction references not in the valud UUID set.1Return the singular context which is not virtual.2Returns all schemas including the concrete schema.UReturns all subschemas which are isomorphic or sub-isomorphic to the concrete schema.     None NoneNoneNoneNoneNone57k      !"#$%i      !"#k      !"#%$ N      !"#$%None^ Left-biased union of attributes.ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_None aScan the atom types and return the resultant ConstructedAtomType or error. Used in typeFromAtomExpr to validate argument types.dUsed to determine if the atom arguments can be used with the data constructor. | This is the entry point for type-checking from RelationalExpression.hs.eFWalks the data and type constructors to extract the type variable map.fSAttempt to match the data constructor argument to a type constructor type variable.iaCreate an atom type iff all type variables are provided. Either Int Text -> ConstructedAtomType Either {Int , Text}m See notes at n6. The typeFromRelation must not include any wildcards.nWhen creating a tuple, the data constructor may not complete the type constructor arguments, so the wildcard "TypeVar x" fills in the type constructor's argument. The tuple type must be resolved before it can be part of a relation, however. Example: Nothing does not specify the the argument in "Maybe a", so allow delayed resolution in the tuple before it is added to the relation. Note that this resolution could cause a type error. Hardly a Hindley-Milner system.oVValidate that the type is provided with complete type variables for type constructors.qZDetermine if two types are equal or compatible (including special handling for TypeVar x).r3Determine if two typeVars are logically compatible.`abcdefghijklmnopqrstuvwxy`abcdefghijklmnopqrstuvwxy`abcdefghijklmnopqrstuvwxy`abcdefghijklmnopqrstuvwxyNonez{|}z{|}z{|}z{|}None ~ ~ ~ ~NoneQConfigure a GHC environment/session which we will use for all script compilation.   NoneERepresents a pointer into the database's transaction graph which the vs can then modify subsequently be committed to extend the transaction graph. The session contains staged (uncommitted) database changes as well as the means to switch between isomorphic schemas.    NoneTNoneNoneNoneNoneNonewCreate a junk named atom function for use with searching for an already existing function in the AtomFunctions HashSet.3AtomFunction constructor for compiled-in functions. Create a sX which can be used to load a new atom function written in Haskell and loaded at runtime.    NoneNone+69:;DQRT,All database values ("atoms") adhere to the ~ typeclass. This class is derivable allowing new datatypes to be easily marshaling between Haskell values and database values.jCreates DatabaseContextExpr necessary to load the type constructor and data constructor into the database. # None!None"NoneDAn optimized form of tuple update which updates vectors efficiently.#None  $None%None%&ATDifference takes two relations of the same type and returns a new relation which contains only tuples which appear in the first relation but not the second.#=Generate a randomly-ordered list of tuples from the relation.%6Return a Relation describing the types in the mapping.&4Return a Relation describing the relation variables.'Randomly resort the tuples. This is useful for emphasizing that two relations are equal even when they are printed to the console in different orders.%      !"#$%&'(%      !"#$%&'(%      !"#$%&'(%      !"#$%&'(&None )*+,-./01 )*+,-./01 )*+,-./01 )*+,-./01'None23232323(None456789:;<=>?@ABCDEFGHIJKLMNOPQR456789:;<=>?@ABCDEFGHIJKLMNOPQR456789:;<=>?@ABCDEFGHIJKLMNOPQR456789:;<=>?@ABCDEFGHIJKLMNOPQR)NoneTHconvert an existing database context into its constituent expression. STUSTUSTUSTU*NoneVVVV+NoneWCreate a uniqueness constraint for the attribute names and relational expression. Note that constraint can span multiple relation variables.X Create a vY which can be used to add a uniqueness constraint to attributes on one relation variable.Y^Create a foreign key constraint from the first relation variable and attributes to the second.WXYWXYWXYWXY,NoneZ[\]Z[\]Z[\]Z[\]-None ^_`abcdefgh ^_`abcdefgh ^_`abcdefgh^_`abcdefgh.None jklmnopqrst jklmnopqrst jklmnopqrst jklmnopqrst/Nonevwxyz{vwxyz{vwxyz{vwxyz{0None#|}~#|}~#~}|"|}~1None2None   3NoneTKUsed to start a fresh database state for a new database context expression.AValidate that the type of the AtomExpr matches the expected type.3Look up the type's name and create a new attribute.+*+$4None5None57Return an error if the schema is not isomorphic to the base database context. A schema is fully isomorphic iff all relvars in the base context are in the "out" relvars, but only once. TODO: add relvar must appear exactly once constraintRelation variables names represented in the virtual schema space. Useful for determining if a relvar name is valid in the schema.LCheck that all mentioned relvars are actually present in the current schema.~If the database context expression adds or removes a relvar, we need to update the isomorphs to create a passthrough Isomorph.IMorph a relational expression in one schema to another isomorphic schema.Apply the isomorphism transformations to the relational expression to convert the relational expression from operating on one schema to a disparate, isomorphic schema.jCreate inclusion dependencies mainly for IsoRestrict because the predicate should hold in the base schema.6None[Returns the notifications which should be triggered based on the transition from the first  to the second .7None8None57 QOperators which manipulate a transaction graph and which transaction the current Session is based upon.7Used for git-style head backtracking such as topic~3^2.bgit equivalent of ~: walk back n parents, arbitrarily choosing a parent when a choice must be made Ugit equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent  rgit equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp 8Record a lookup for a specific transaction in the graph."Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graph#Returns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple.%Search from a past graph point to all following heads for a specific transaction. If found, return the transaction path, otherwise a RelationalError.)After splicing out a subgraph, run it through this function to remove references to transactions which are not in the subgraph..#Create a temporary branch for commit, merge the result to head, delete the temporary branch. This is useful to atomically commit a transaction, avoiding a TransactionIsNotHeadError but trading it for a potential MergeError. this is not a GraphOp because it combines multiple graph operations3      !"#$%&'()*+,-.3      !"#$%&'()*+,-.3      !"#$%&'()*+,-.%      !"#$%&'()*+,-.9None9;AThe TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).<=>?@ABCDEFGHIJKL <=>?@ABCDEFGAL@K?J>I=H<BCDEFG<=>?@ABCDEFGHIJKL:None57}The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.2MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~2}~{|yzwxuvstqropmnklijghefcdab_`]^[\YZWXUVSTQROPMNMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~;NoneTThe incremental writer writes the transactions ids specified by the second argument.None57T'4There are several reasons why a connection can fail.wThe d represents either local or remote access to a database. All operations flow through the connection."When a notification is fired, the ; is evaluated in the commit's pre-change context while the d is evaluated in the post-change context and they are returned along with the original notification.xIUsed for callbacks from the server when monitored changes have been made. Construct a  to describe how to make the a. The database can be run within the current process or running remotely via distributed-process.The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.6The empty notification callback ignores all callbacks. Create a D for use in connecting to a remote server using distributed-process.>Use this for connecting to remote servers on the default port.IUse this for connecting to remote servers with the default database name.EUse this for connecting to remote servers with the default head name.Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events. To create a ) to a remote or local database, create a  and call .GCreate a new session at the transaction id and return the session's Id.Call m with a transaction graph's head's name to create a new session pinned to that head. This function returns a [ which can be used in other function calls to reference the point in the transaction graph.tUsed internally for server connections to keep track of remote nodes for the purpose of sending notifications later.ODiscards a session, eliminating any uncommitted changes present in the session.J cleans up the database access connection and closes any relevant sockets.=Returns the name of the currently selected isomorphic schema.&Switch to the named isomorphic schema.Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.Similar to a git rebase, k atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the i> and commits the merge. This is useful to reduce incidents of Gs but at the risk of merge errors (thus making it similar to rebasing).[Execute a database context IO-monad-based expression for the given session and connection. ss modify the DatabaseContext but cannot be purely implemented. this is almost completely identical to executeDatabaseContextExpr aboveExecute a transaction graph expression in the context of the session and connection. Transaction graph operators modify the transaction graph state.dA trans-graph expression is a relational query executed against the entirety of a transaction graph.ESchema expressions manipulate the isomorphic schemas for the current .After modifying a ,  the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.(Discard any changes made in the current  and . This resets the disconnected transaction to reference the original database context of the parent transaction and is a very cheap operation.yoWrite the transaction graph to disk. This function can be used to incrementally write new transactions to disk.Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types. Return a MapL of the database's constraints at the context of the session and connection.Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.Return a relation which represents the current state of the global transaction graph. The attributes are * current- boolean attribute representing whether or not the current session references this transaction * head- text attribute which is a non-empty i iff the transaction references a head. * id- id attribute of the transaction * parents- a relation-valued attribute which contains a relation of transaction ids which are parent transaction to the transactionEReturns the names and types of the relation variables in the current .hReturns the transaction id for the connection's disconnected transaction committed parent transaction. YReturns Just the name of the head of the current disconnected transaction or Nothing. .Returns a listing of all available atom types.wRuns an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.iz{|}~wxy#45679:;<=>?@ABCDEFGVWXYZ[ijklmnopqstuv|{wxyz}~      !"DWXY     A'i?@ABvwxyz{|}~stu4567DA     >WXY;<=CDEFG      !"9:VWXYZ[jklmnopqMz{|}~ wxy<NoneI AA union of connection and other errors that can be returned from .A simple alternative to connectProjectM36* which includes simple session management.Same as  but always connects to the master branch.Closes the database connection.Runs a Db monad which may include some database updates. If an exception or error occurs, the transaction is rolled back. Otherwise, the transaction is committed to the head of the current branch.Same a 1 except that the merge strategy can be specified. Execute a v in the DB monad. Database context expressions manipulate the state of the database. In case of an error, the transaction is terminated and the connection's session is rolled back.Run a  query in the DB\ monad. Relational expressions perform read-only queries against the current database state. Run a vd update expression. If there is an error, just return it without cancelling the current transaction.!Run a [ query expression. If there is an error, just return it without cancelling the transaction."tUnconditionally roll back the current transaction and throw an exception to terminate the execution of the Db monad.#>Cancel a transaction and carry some error information with it.$ Converts the  result from a 6 action into an immediate cancel in the case of error. !"#$%?@ABv|{wxyz}~      !" !"#$ !#$"      !"?@ABvwxyz{|}~ !"#$%=None -./0123456 -.30/12456 -./0123456-./0123456>NoneKcReturns a relation which lists the names of relvars in the current session as well as its types. 89:;<=>?@ABCDEFGHIJKLMNOPQR89:;<=>?@ABCDEFGHIJKLMNOPQR:98;<=>?@ABCDEFGHIJKLMNOPQR89:;<=>?@ABCDEFGHIJKLMNOPQR?NoneTVTA notification callback which logs the notification to stderr and does nothing else.WLA synchronous function to start the project-m36 daemon given an appropriate -. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.STUVWSTUVWSTUVWSTUVW@None XYZ[\]^_` XYZ[\]^_` XYZ[\]^_` XYZ[\]^_`ANoneababababBNone 69:;QRTk Convert a  Traverseable of gs to an { v. This is useful for converting, for example, a list of data values to a set of Insert expressions which can be used to add the values to the database.l Convert a g to a create a xH expression which can be used to create an empty relation variable. Use kG to insert the actual tuple data. This function is typically used with CD.cdefghijklmnopq cdfegjhiklklghijhijcdefqponm cdefghijhijklmnopqEFGEFHEFHIJKLMNOPQRSSTUVWXYZ[\]^_`abcdefghijklmnoopqrsstuvwxyz{|{}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                              !"#$%&'()*+,-./0123456789:;a<=>?@ABCDZEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~* !!""""""""""""""" " " " " """"""""##########$$$ $!$"%#%$%z%w%x%%%&%'%(%)%*%+%,%-%%.%/%i%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B&C&D&E&F&G&H&I&J&K'L'M(N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`(a(b(c(d(e(f(g(h(i(j(k(l))m)n*o+p+q+r,s,t,u,v-w-x-y-z-{-|-}-~----............//////00000000000000000000000000000000000111122222222223333333333333333333333333333333333333333333445555555555555555555555555 5 5 5 5 5677788888888888888 8!8"8"8#8$8%8&8'8(8)8*8+8,8-8.8/808182838485868788898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q9R9S9T9U9V9W9X9Y9Z9[9\9]9:9>93999@:^:^:_:_:`:`:a:a:b:b:c:c:d:d:e:e:f:f:g:g:h:h:i:i:j:j:k:k:l:l:m:m:n:n:o:o:p:p:q:q:r:r:s:s:t:t:u:u:v:v:w:x:y:z:{:|:}:~::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;D@<<<<<<<<<<< < < < < <<<<<<<<<<<========== =!>">#>$>%>&>'>(>)>*>+>,>->.>/>0>1>2>3>4>5>6>7>8>9>:>;><?=?>???@?A@B@C@D@E@F@G@H@I@JAKALBMBNBOBPBQBRBSBTBUBVBWBXBYBZB[\]^_`abcddefghhijklmnopbqrstuvwxyz{|}~<<<<&project-m36-0.3-6ISpcBZwnv1Gd5svoztbShProjectM36.ClientProjectM36.PersistProjectM36.MiscUtilsProjectM36.FileLock'ProjectM36.DatabaseContextFunctionErrorProjectM36.AtomFunctionErrorProjectM36.BaseProjectM36.DataTypes.Primitive"ProjectM36.DisconnectedTransactionProjectM36.FunctionalDependencyProjectM36.TransactionProjectM36.TypeConstructorProjectM36.DataConstructorDefProjectM36.TypeConstructorDefProjectM36.DataTypes.MaybeProjectM36.DataTypes.ListProjectM36.ErrorProjectM36.AttributeProjectM36.AtomTypeProjectM36.AttributeNames"ProjectM36.DatabaseContextFunctionProjectM36.ScriptSessionProjectM36.SessionProjectM36.AtomFunctionBodyProjectM36.DataTypes.ByteStringProjectM36.DataTypes.DateTimeProjectM36.DataTypes.DayProjectM36.DataTypes.IntervalProjectM36.AtomFunctionProjectM36.DataTypes.EitherProjectM36.AtomableProjectM36.DataTypes.BasicProjectM36.AtomProjectM36.TupleProjectM36.Relation.Show.CSVProjectM36.TupleSetProjectM36.Relation"ProjectM36.AtomFunctions.PrimitiveProjectM36.AtomFunctions.BasicProjectM36.Transaction.PersistProjectM36.DatabaseContextProjectM36.InclusionDependencyProjectM36.KeyProjectM36.DateExamplesProjectM36.Relation.Parse.CSV ProjectM36.Relation.Show.GnuplotProjectM36.Relation.Show.HTMLProjectM36.Relation.Show.TermProjectM36.Sessions!ProjectM36.TransactionGraph.MergeProjectM36.RelationalExpression'ProjectM36.DatabaseContextFunctionUtilsProjectM36.IsomorphicSchemaProjectM36.NotificationsProjectM36.StaticOptimizerProjectM36.TransactionGraph)ProjectM36.TransGraphRelationalExpression!ProjectM36.Server.RemoteCallTypes#ProjectM36.TransactionGraph.PersistProjectM36.Client.SimpleProjectM36.Server.ConfigProjectM36.Server.EntryPointsProjectM36.ServerProjectM36.Server.ParseArgs ProjectM36.TransactionGraph.ShowProjectM36.TupleableDataProxy0distributed-process-0.6.6-CTUSn8srUOF1BPYTHMh7Ta*Control.Distributed.Process.Internal.Types nodeAddressNodeIdDiskSync NoDiskSync FsyncDiskSync writeFileSync renameSyncwriteBSFileSyncdupesLockTypeReadLock WriteLockLockFile lockStruct openLockFile closeLockFilelockFile unlockFileDatabaseContextFunctionError DatabaseContextFunctionUserError%$fGenericDatabaseContextFunctionError $fEqDatabaseContextFunctionError"$fShowDatabaseContextFunctionError$$fBinaryDatabaseContextFunctionError$$fNFDataDatabaseContextFunctionErrorAtomFunctionErrorAtomFunctionUserErrorAtomFunctionTypeMismatchErrorInvalidIntervalOrderingErrorInvalidIntervalBoundariesErrorAtomFunctionEmptyRelationError#AtomTypeDoesNotSupportOrderingError#AtomTypeDoesNotSupportIntervalErrorAtomFunctionBytesDecodingError$fGenericAtomFunctionError$fEqAtomFunctionError$fShowAtomFunctionError$fBinaryAtomFunctionError$fNFDataAtomFunctionErrorDatabaseContextFunctionsDatabaseContextFunction dbcFuncName dbcFuncType dbcFuncBodyDatabaseContextFunctionBodyDatabaseContextFunctionBodyType!DatabaseContextFunctionBodyScriptDatabaseContextFunctionName MergeStrategyUnionMergeStrategyUnionPreferMergeStrategySelectedBranchMergeStrategy TupleExpr TupleExprBaseAttributeExprBaseAttributeAndTypeNameExprNakedAttributeExpr AttributeExprPersistenceStrategy NoPersistenceMinimalPersistenceCrashSafePersistenceAttributeNamesInvertedAttributeNamesUnionAttributeNamesIntersectAttributeNames AtomFunction atomFuncName atomFuncType atomFuncBodyAtomFunctionBodyAtomFunctionBodyTypeAtomFunctionBodyScriptAtomFunctionName AtomFunctionsExtendTupleExprExtendTupleExprBaseAttributeExtendTupleExpr AtomExprBaseAttributeAtomExpr NakedAtomExprFunctionAtomExprRelationAtomExprConstructedAtomExprAtomExprDisconnectedTransaction DirtyFlag Transaction TransactionIdTransactionInfoMergeTransactionInfoTransactionGraphTransactionHeadsHeadNameRestrictionPredicateExprBase TruePredicate AndPredicate OrPredicate NotPredicateRelationalExprPredicateAtomExprPredicateAttributeEqualityPredicateRestrictionPredicateExprDatabaseContextIOExprAddAtomFunctionAddDatabaseContextFunctionDatabaseContextExpr NoOperationDefineUndefineAssignInsertDeleteUpdateAddInclusionDependencyRemoveInclusionDependencyAddNotificationRemoveNotificationAddTypeConstructorRemoveTypeConstructorRemoveAtomFunctionRemoveDatabaseContextFunctionExecuteDatabaseContextFunction MultipleExprDatabaseContextExprNameAttributeNameAtomExprMapInclusionDependency IncDepNameDatabaseContextinclusionDependenciesrelationVariables atomFunctions dbcFunctions notificationstypeConstructorMappingSchemaIsomorphsSchemaIsomorph IsoRestrict IsoRenameIsoUnionSchemaSchemas Subschemas SchemaNameRelationVariablesInclusionDependenciesDataConstructorDefArg$DataConstructorDefTypeConstructorArg DataConstructorDefTypeVarNameArgDataConstructorDefsDataConstructorDef AtomTypeNameDataConstructorNameTypeConstructorArgNameTypeConstructorNameTypeConstructorMappingTypeConstructorADTypeConstructorPrimitiveTypeConstructor TypeVariableTypeConstructorDefADTypeConstructorDefPrimitiveTypeConstructorDef TypeVarName Notification changeExpr reportOldExpr reportNewExpr NotificationsNotificationNameRelationalExprBaseMakeRelationFromExprsMakeStaticRelationExistingRelationRelationVariableProjectUnionJoinRename DifferenceGroupUngroupRestrictEquals NotEqualsExtendRelationalExpr RelVarNameRelationCardinality CountableFiniteRelation RelationTupleRelationTupleSetasList Attributes Attribute AttributeName TypeVarMapAtomType IntAtomTypeIntegerAtomTypeDoubleAtomType TextAtomType DayAtomTypeDateTimeAtomTypeByteStringAtomType BoolAtomTypeIntervalAtomTypeRelationAtomTypeConstructedAtomTypeTypeVariableType OpenIntervalAtom IntegerAtomIntAtom DoubleAtomTextAtomDayAtom DateTimeAtomByteStringAtomBoolAtom IntervalAtom RelationAtomConstructedAtom StringTypeisRelationAtomTypeattributesEqualsortedAttributesIndicestransactionsForGraphtransactionHeadsForGraph transactionIdtransactionInfo$fEqDatabaseContextFunction!$fHashableDatabaseContextFunction#$fNFDataDatabaseContextFunctionBody$fBinaryTupleExprBase$fShowAtomFunction$fEqAtomFunction$fHashableAtomFunction$fShowAtomFunctionBody$fNFDataAtomFunctionBody$fBinaryExtendTupleExprBase$fBinaryAtomExprBase$fOrdTransaction$fEqTransaction$fBinaryTransactionInfo$$fBinaryRestrictionPredicateExprBase$fBinaryInclusionDependency$fBinaryRelationalExprBase$fBinaryRelation$fHashableRelation$fNFDataRelation $fEqRelation$fNFDataRelationTuple$fEqRelationTuple$fBinaryRelationTuple$fHashableRelationTuple$fNFDataRelationTupleSet$fEqRelationTupleSet$fReadRelation$fHashableAttribute $fHashableMap $fBinaryDay$fBinaryUTCTime$fHashableAtom$fEqRelationCardinality$fShowRelationCardinality$fGenericRelationCardinality$fOrdRelationCardinality $fEqAtomType$fNFDataAtomType$fGenericAtomType$fBinaryAtomType$fShowAtomType $fEqAttribute$fShowAttribute$fGenericAttribute$fNFDataAttribute$fBinaryAttribute$fShowTypeConstructor$fGenericTypeConstructor$fBinaryTypeConstructor$fEqTypeConstructor$fNFDataTypeConstructor$fShowTypeConstructorDef$fGenericTypeConstructorDef$fBinaryTypeConstructorDef$fEqTypeConstructorDef$fNFDataTypeConstructorDef$fEqAtom $fShowAtom $fBinaryAtom $fNFDataAtom $fGenericAtom$fShowRelation$fGenericRelation$fHashableRelationTupleSet$fShowRelationTupleSet$fGenericRelationTupleSet$fBinaryRelationTupleSet$fShowRelationTuple$fGenericRelationTuple$fShowDataConstructorDefArg$fGenericDataConstructorDefArg$fBinaryDataConstructorDefArg$fEqDataConstructorDefArg$fNFDataDataConstructorDefArg$fEqDataConstructorDef$fShowDataConstructorDef$fBinaryDataConstructorDef$fGenericDataConstructorDef$fNFDataDataConstructorDef$fShowTransactionInfo$fGenericTransactionInfo$fGenericAtomFunction$fNFDataAtomFunction$fEqAttributeNames$fShowAttributeNames$fGenericAttributeNames$fBinaryAttributeNames$fNFDataAttributeNames$fShowPersistenceStrategy$fReadPersistenceStrategy$fEqAttributeExprBase$fShowAttributeExprBase$fGenericAttributeExprBase$fBinaryAttributeExprBase$fNFDataAttributeExprBase$fEqTupleExprBase$fShowTupleExprBase$fGenericTupleExprBase$fNFDataTupleExprBase$fEqAtomExprBase$fShowAtomExprBase$fGenericAtomExprBase$fNFDataAtomExprBase$fShowRelationalExprBase$fEqRelationalExprBase$fGenericRelationalExprBase$fNFDataRelationalExprBase$fShowExtendTupleExprBase$fEqExtendTupleExprBase$fGenericExtendTupleExprBase$fNFDataExtendTupleExprBase"$fShowRestrictionPredicateExprBase $fEqRestrictionPredicateExprBase%$fGenericRestrictionPredicateExprBase$$fNFDataRestrictionPredicateExprBase$fGenericSchemaIsomorph$fBinarySchemaIsomorph$fShowSchemaIsomorph$fGenericSchema$fBinarySchema$fShowInclusionDependency$fEqInclusionDependency$fGenericInclusionDependency$fNFDataInclusionDependency$fShowNotification$fEqNotification$fBinaryNotification$fGenericNotification$fNFDataNotification$fEqMergeStrategy$fShowMergeStrategy$fBinaryMergeStrategy$fGenericMergeStrategy$fNFDataMergeStrategy$fShowDatabaseContextExpr$fEqDatabaseContextExpr$fBinaryDatabaseContextExpr$fGenericDatabaseContextExpr$fShowDatabaseContextIOExpr$fEqDatabaseContextIOExpr$fGenericDatabaseContextIOExpr$fBinaryDatabaseContextIOExpr $fGenericDatabaseContextFunction$fNFDataDatabaseContextFunction$fNFDataDatabaseContext$fGenericDatabaseContextprimitiveTypeConstructorMappingintTypeConstructordoubleTypeConstructortextTypeConstructordayTypeConstructoratomTypeForAtomconcreteDatabaseContextschemasparentIdFunctionalDependency,inclusionDependenciesForFunctionalDependencytransactionTimestamptransactionParentIdstransactionChildIdstransactionSetChildren!filterTransactionInfoTransactions filterParentfilterTransaction subschemasname argumentstypeVarsemptyDataConstructorfieldstypeVarsInDefArg maybeAtomTypemaybeTypeConstructorMappingmaybeAtomFunctions listAtomTypelistTypeConstructorMapping listLength listMaybeHeadlistAtomFunctionslistCons ServerErrorRequestTimeoutErrorProcessDiedError SchemaErrorRelVarReferencesMissingRelVarInReferencedMoreThanOnceRelVarOutReferencedMoreThanOnceScriptCompilationErrorTypeCheckCompilationErrorSyntaxErrorCompilationErrorScriptCompilationDisabledErrorOtherScriptCompilationError MergeErrorSelectedHeadMismatchMergeErrorPreferredHeadMissingMergeError$StrategyViolatesConstraintMergeErrorInvalidMergeStrategyError)DisconnectedTransactionNotAMergeHeadError#StrategyViolatesComponentMergeError*StrategyViolatesRelationVariableMergeError)StrategyViolatesTypeConstructorMergeErrorPersistenceErrorInvalidDirectoryErrorMissingTransactionErrorWrongDatabaseFormatVersionErrorRelationalErrorNoSuchAttributeNamesError TupleAttributeCountMismatchErrorTupleAttributeTypeMismatchErrorAttributeCountMismatchErrorAttributeNamesMismatchErrorAttributeNameInUseError!AttributeIsNotRelationValuedErrorCouldNotInferAttributesRelVarNotDefinedErrorRelVarAlreadyDefinedError!RelVarAssignmentTypeMismatchErrorInclusionDependencyCheckError!InclusionDependencyNameInUseError$InclusionDependencyNameNotInUseError ParseErrorPredicateExpressionError NoCommonTransactionAncestorErrorNoSuchTransactionErrorRootTransactionTraversalError$HeadNameSwitchingHeadProhibitedErrorNoSuchHeadNameErrorUnknownHeadError%NewTransactionMayNotHaveChildrenErrorParentCountTraversalError NewTransactionMissingParentErrorTransactionIsNotAHeadErrorTransactionGraphCycleErrorSessionIdInUseErrorNoSuchSessionErrorFailedToFindTransactionErrorTransactionIdInUseErrorNoSuchFunctionErrorNoSuchTypeConstructorNameTypeConstructorAtomTypeMismatchAtomTypeMismatchErrorTypeConstructorNameMismatch*AtomTypeTypeConstructorReconciliationErrorDataConstructorNameInUseError)DataConstructorUsesUndeclaredTypeVariableTypeConstructorTypeVarsMismatchTypeConstructorTypeVarMissing$TypeConstructorTypeVarsTypesMismatchDataConstructorTypeVarsMismatch'AtomFunctionTypeVariableResolutionError AtomFunctionTypeVariableMismatchAtomTypeNameInUseError/IncompletelyDefinedAtomTypeWithConstructorErrorAtomTypeNameNotInUseErrorFunctionNameInUseErrorFunctionNameNotInUseErrorEmptyCommitError"FunctionArgumentCountMismatchError)ConstructedAtomArgumentCountMismatchErrorNoSuchDataConstructorErrorNoSuchTypeConstructorErrorInvalidAtomTypeNameAtomTypeNotSupportedAtomOperatorNotSupportedEmptyTuplesErrorAtomTypeCountErrorAtomFunctionTypeErrorPrecompiledFunctionRemoveError)RelationValuedAttributesNotSupportedErrorNotificationNameInUseErrorNotificationNameNotInUseError ImportError ExportErrorUnhandledExceptionErrorMergeTransactionError ScriptErrorDatabaseLoadErrorSubschemaNameInUseErrorSubschemaNameNotInUseErrorSchemaCreationErrorImproperDatabaseStateErrorMultipleErrors someErrors!$fExceptionScriptCompilationError$fNFDataMergeError$fShowPersistenceError$fEqPersistenceError$fGenericPersistenceError$fBinaryPersistenceError$fNFDataPersistenceError$fShowMergeError$fEqMergeError$fGenericMergeError$fBinaryMergeError$fShowScriptCompilationError$fEqScriptCompilationError$fGenericScriptCompilationError$fBinaryScriptCompilationError$fNFDataScriptCompilationError$fShowSchemaError$fEqSchemaError$fGenericSchemaError$fBinarySchemaError$fNFDataSchemaError$fShowRelationalError$fEqRelationalError$fGenericRelationalError$fBinaryRelationalError$fNFDataRelationalError$fGenericServerError$fBinaryServerError$fEqServerErrorarityemptyAttributesnullattributesFromList attributeNameatomType atomTypes addAttributejoinAttributes addAttributesdeleteAttributeNamerenameAttributerenameAttributesatomTypeForAttributeNameattributeForNameattributesForNamesattributeNameSetattributeNamesattributesContainedattributeNamesContainednonMatchingAttributeNameSetmatchingAttributeNameSetattributeNamesNotContainedsortedAttributeNameListattributesDifferencevectorUniqueifyverifyAttributesattributesAsMapunion intersectionfindDataConstructoratomTypeForDataConstructorName atomTypeForDataConstructorDefArg!isValidAtomTypeForTypeConstructoratomTypeForDataConstructorresolveDataConstructorTypeVars!resolveDataConstructorArgTypeVarsresolveTypeConstructorTypeVarsvalidateTypeConstructorDefatomTypeForTypeConstructorfindTypeConstructorresolveAtomTyperesolveAtomTypesInTypeVarMapresolveTypeInAtomresolveTypesInTuplevalidateAtomType validateTupleatomTypeVerifytypeVarMapsVerifyprettyAtomTypeprettyAttributeresolveTypeVariablesresolveTypeVariableresolveFunctionReturnValue*resolvedAtomTypesForDataConstructorDefArgs(resolvedAtomTypeForDataConstructorDefArgemptyall%projectionAttributesForAttributeNamesinvertAttributeNamesemptyDatabaseContextFunctiondatabaseContextFunctionForNameevalDatabaseContextFunctionbasicDatabaseContextFunctions#precompiledDatabaseContextFunctions!isScriptedDatabaseContextFunctiondatabaseContextFunctionScript!databaseContextFunctionReturnType%createScriptedDatabaseContextFunctionScriptSessionErrorScriptSessionLoadError ScriptSessionhscEnvatomFunctionBodyTypedbcFunctionBodyTypeinitScriptSession addImportshowType mkTypeForName compileScripttypeCheckScript$fShowScriptSessionErrorSession SessionIddefaultSchemaNamedisconnectedTransactionisDirty schemaName setSchemaNamecompiledAtomFunctionBodybytestringAtomFunctionsdateTimeAtomFunctionsdayAtomFunctionsdayTypeConstructorMappingsupportsIntervalsupportsOrdering atomComparecreateIntervalintervalAtomFunctionsintervalOverlapsfoldAtomFuncTypeatomFunctionForNameemptyAtomFunctioncompiledAtomFunctionevalAtomFunctionextractAtomFunctionTypeisScriptedAtomFunctionatomFunctionScriptcreateScriptedAtomFunctioneitherAtomTypeeitherTypeConstructorMappingeitherAtomFunctions AtomableGtoAtomG fromAtomG toAtomTypeGtoAtomsGtoAddTypeExprGgetConstructorsGgetConstructorArgsGAtomabletoAtomfromAtom toAtomType toAddTypeExpr$fAtomableGTYPE:+:$fAtomableGTYPE:*:$fAtomableGTYPEU1$fAtomableGTYPEK1$fAtomableGTYPEM1$fAtomableGTYPEM10$fAtomableGTYPEM11 $fAtomable[]$fAtomableEither$fAtomableMaybe$fAtomableBool$fAtomableByteString$fAtomableUTCTime $fAtomableDay$fAtomableText$fAtomableDouble $fAtomableInt$fAtomableIntegerbasicTypeConstructorMappingrelationForAtom atomToText emptyTuple tupleSizetupleAttributeNameSettupleAttributes tupleAssocs tupleAtomsatomForAttributeNameatomsForAttributeNamesvectorIndicesForAttributeNamesrelationForAttributeNametupleRenameAttributemkRelationTuplemkRelationTuplesmkRelationTupleFromMapsingleTupleSetJoinsingleTupleJoin vectorUnion tupleExtendtupleAtomExtendtupleSortedAssocs tupleProjecttupleIntersectionupdateTupleWithAtoms tupleToMap verifyTuple reorderTuple trimTuple RecordAtomunAtomRecordRelationTupleunTuple relationAsCSV$fToFieldRecordAtom#$fDefaultOrderedRecordRelationTuple"$fToNamedRecordRecordRelationTuple emptyTupleSetsingletonTupleSetverifyTupleSet mkTupleSetmkTupleSetFromListRestrictionFilter attributesatomTypeForNamemkRelationFromListemptyRelationWithAttrs mkRelationmkRelationDeferVerifymkRelationFromTuples relationTrue relationFalsesingletonTupleprojectrenamedegree cardinalitygroup restrictEqungroup tupleUngroupattributesForRelvalrestrictjoin differencerelMap relMogrifyrelFoldtoListimageRelationFortypesAsRelationrelationVariablesAsRelationrandomizeTupleOrderoneTupleprimitiveAtomFunctionsintegerAtomFuncLessThan boolAtomNot relationSum relationCount relationMax relationMincastInt castIntegerbasicAtomFunctionsprecompiledAtomFunctionsgetDirectoryNamestempTransactionDirtransactionDirtransactionInfoPath relvarsDir incDepsDir atomFuncsPath dbcFuncsDir typeConsPathsubschemasPathreadTransactionwriteTransaction writeRelVar writeRelVars readRelVarswriteAtomFuncs readAtomFuncs loadAtomFunc readAtomFunc writeDBCFuncs writeDBCFunc readDBCFuncs readDBCFunc writeIncDep writeIncDeps readIncDep readIncDepsreadSubschemaswriteSubschemaswriteTypeConstructorMappingreadTypeConstructorMapping$databaseContextAsDatabaseContextExprbasicDatabaseContextinclusionDependenciesAsRelationinclusionDependencyForKeydatabaseContextExprForUniqueKey databaseContextExprForForeignKey dateExamples suppliersRelsupplierProductsRel productsRelCsvImportError CsvParseErrorAttributeMappingErrorHeaderAttributeMismatchErrorcsvDecodeOptions csvAsRelation parseCSVAtomPcapitalizedIdentifiertakeToEndOfDataparens quotedString$fShowCsvImportError PlotErrorInvalidAttributeCountErrorInvalidAttributeTypeErrorintFromAtomIndexgraph1DRelationpoints1DRelationgraph2DRelationpoints2DRelationgraph3DRelationpoints3DRelation plotRelation$fShowPlotErrorattributesAsHTMLrelationAsHTML writeHTMLwriteRel tupleAsHTMLtupleSetAsHTMLTableCellTermSize termLengthboxVboxHboxTLboxTRboxBLboxBRboxLBboxRBboxTBboxBBboxCdboxHdboxLdboxRaddRow cellLocations breakLines cellSizesrelationAsTable showParensshowAtom renderTable renderHeader renderHBarleftPaddedString renderRow renderBodyorderedAttributesorderedAttributeNames repeatString showRelationSessions stmMapToListuuidAtomsessionsAsRelationMergePreference PreferFirst PreferSecond PreferNeitherunionMergeMapsunionMergeRelationunionMergeRelVarsunionMergeAtomFunctions unionMergeTypeConstructorMapping"unionMergeDatabaseContextFunctionsRelationalExprState DatabaseStateDatabaseStateElems ResultAccumresultAccumFuncresultAccumResultResultAccumFuncResultAccumNameRelationalExprStateElemsRelationalExprStateTupleElemsRelationalExprStateAttrsElemsDatabaseContextExprDetailsCountUpdatedTuplesdatabaseContextExprDetailsFuncfreshDatabaseStatemkRelationalExprState"mergeTuplesIntoRelationalExprState&mergeAttributesIntoRelationalExprStategetStateContextputStateContextstateElemsContextsetStateElemsContextevalRelationalExpr setRelVar deleteRelVarevalDatabaseContextExprevalDatabaseContextIOExprupdateTupleWithAtomExprscheckConstraintstypeForRelationalExprcontextWithEmptyTupleSetsliftEpredicateRestrictionFiltertupleExprCheckNewAttrNameextendTupleExpressionProcessor evalAtomExprtypeFromAtomExprverifyAtomExprTypes evalAttrExpr evalTupleExpr$fShowRelationalExprStateElemsexecuteDatabaseContextExprexecuteRelationalExpr SchemaExpr AddSubschemaRemoveSubschema isomorphsvalidateSchemainvertisomorphInRelVarNamesisomorphsInRelVarNamesisomorphOutRelVarNamesisomorphsOutRelVarNamesvalidateRelationalExprInSchemaprocessRelationalExprInSchema#validateDatabaseContextExprInSchema"processDatabaseContextExprInSchema&processDatabaseContextExprSchemaUpdate'processDatabaseContextExprSchemasUpdate relExprMorphrelExprMogrifydatabaseContextExprMorph"applyRelationalExprSchemaIsomorphsinclusionDependencyInSchemainclusionDependenciesInSchemarelationVariablesInSchema%applyRelationVariablesSchemaIsomorphs%applySchemaIsomorphsToDatabaseContextcreateIncDepsForIsomorphevalSchemaExpr$fGenericSchemaExpr$fBinarySchemaExpr$fShowSchemaExprnotificationChanges!applyStaticRelationalOptimizationapplyStaticDatabaseOptimization applyStaticPredicateOptimizationROTransactionGraphOperator ShowGraphTransactionGraphOperator JumpToHeadJumpToTransactionWalkBackToTimeBranch DeleteBranchMergeTransactionsCommitRollbackTransactionIdHeadBacktrack TransactionIdHeadParentBacktrack TransactionIdHeadBranchBacktrackTransactionStampHeadBacktrackTransactionIdLookupTransactionIdHeadNameLookupisCommitbootstrapTransactionGraphemptyTransactionGraphtransactionForHeadheadListheadNameForTransactiontransactionForIdtransactionsForIdsisRootTransactionparentTransactionschildTransactions addBranchaddDisconnectedTransactionaddTransactionToGraph validateGraphwalkParentTransactionswalkChildTransactions evalGraphOpgraphAsRelationtransactionParentsRelationcreateMergeTransactionvalidateHeadNamesubGraphOfFirstCommonAncestorpathToTransactionmergeTransactionsshowTransactionStructureXshowGraphStructureXfilterSubGraphcreateUnionMergeTransactionlookupTransaction traverseGraphbacktrackGraphautoMergeToHead $fShowTransactionIdHeadBacktrack$fEqTransactionIdHeadBacktrack"$fBinaryTransactionIdHeadBacktrack#$fGenericTransactionIdHeadBacktrack$fShowTransactionIdLookup$fEqTransactionIdLookup$fBinaryTransactionIdLookup$fGenericTransactionIdLookup$fEqTransactionGraphOperator$fShowTransactionGraphOperator $fBinaryTransactionGraphOperator!$fGenericTransactionGraphOperator $fShowROTransactionGraphOperatorTransGraphAttributeExprTransGraphAtomExpr"TransGraphRestrictionPredicateExprTransGraphTupleExprTransGraphExtendTupleExprTransGraphRelationalExprevalTransGraphRelationalExprevalTransGraphTupleExprevalTransGraphAtomExpr&evalTransGraphRestrictionPredicateExprevalTransGraphExtendTupleExprevalTransGraphAttributeExprRetrieveTypeConstructorMappingExecuteAutoMergeToHeadRetrieveSessionIsDirty TestTimeoutRetrieveCurrentSchemaNameRetrieveRelationVariableSummaryRetrieveAtomTypesAsRelation CloseSessionCreateSessionAtHeadCreateSessionAtCommitRetrieveHeadTransactionIdRetrieveTransactionGraph"RetrievePlanForDatabaseContextExprRetrieveInclusionDependenciesExecuteSetCurrentSchemaExecuteSchemaExprExecuteTypeForRelationalExprExecuteHeadNameExecuteTransGraphRelationalExprExecuteGraphExprExecuteDatabaseContextIOExprExecuteDatabaseContextExprExecuteRelationalExprLogoutLogin $fBinaryLogin$fGenericLogin$fBinaryLogout$fGenericLogout$fBinaryExecuteRelationalExpr$fGenericExecuteRelationalExpr"$fBinaryExecuteDatabaseContextExpr#$fGenericExecuteDatabaseContextExpr$$fBinaryExecuteDatabaseContextIOExpr%$fGenericExecuteDatabaseContextIOExpr$fBinaryExecuteGraphExpr$fGenericExecuteGraphExpr'$fBinaryExecuteTransGraphRelationalExpr($fGenericExecuteTransGraphRelationalExpr$fBinaryExecuteHeadName$fGenericExecuteHeadName$$fBinaryExecuteTypeForRelationalExpr%$fGenericExecuteTypeForRelationalExpr$fBinaryExecuteSchemaExpr$fGenericExecuteSchemaExpr$fBinaryExecuteSetCurrentSchema $fGenericExecuteSetCurrentSchema%$fBinaryRetrieveInclusionDependencies&$fGenericRetrieveInclusionDependencies*$fBinaryRetrievePlanForDatabaseContextExpr+$fGenericRetrievePlanForDatabaseContextExpr $fBinaryRetrieveTransactionGraph!$fGenericRetrieveTransactionGraph!$fBinaryRetrieveHeadTransactionId"$fGenericRetrieveHeadTransactionId$fBinaryCreateSessionAtCommit$fGenericCreateSessionAtCommit$fBinaryCreateSessionAtHead$fGenericCreateSessionAtHead$fBinaryCloseSession$fGenericCloseSession#$fBinaryRetrieveAtomTypesAsRelation$$fGenericRetrieveAtomTypesAsRelation'$fBinaryRetrieveRelationVariableSummary($fGenericRetrieveRelationVariableSummary!$fBinaryRetrieveCurrentSchemaName"$fGenericRetrieveCurrentSchemaName$fBinaryTestTimeout$fGenericTestTimeout$fBinaryRetrieveSessionIsDirty$fGenericRetrieveSessionIsDirty$fBinaryExecuteAutoMergeToHead$fGenericExecuteAutoMergeToHead&$fBinaryRetrieveTypeConstructorMapping'$fGenericRetrieveTypeConstructorMapping LockFileHashexpectedVersiontransactionLogFileNametransactionLogPath headsPath lockFilePathcheckForOtherVersionssetupDatabaseDirbootstrapDatabaseDirtransactionGraphPersisttransactionsPersisttransactionGraphHeadsPersisttransactionGraphHeadsLoadtransactionGraphLoadreadTransactionIfNecessarywriteGraphTransactionIdFile readGraphTransactionIdFileDigestreadGraphTransactionIdFileConnectionErrorSetupDatabaseDirectoryErrorIOExceptionErrorNoSuchDatabaseByNameError LoginError ConnectionInProcessConnectionRemoteProcessConnectionEvaluatedNotification notificationreportOldRelationreportNewRelationConnectionInfoInProcessConnectionInfoRemoteProcessConnectionInfoRequestTimeoutExceptionRemoteProcessDiedExceptionNotificationCallback DatabaseNamePortHostnameemptyNotificationCallback createNodeIddefaultServerPortdefaultDatabaseNamedefaultHeadNamedefaultRemoteConnectionInforemoteDBLookupNameconnectProjectM36createSessionAtCommitcreateSessionAtHead addClientNode closeSessionclose closeRemote_currentSchemaNamesetCurrentSchemaNameexecuteDatabaseContextIOExprexecuteGraphExprexecuteTransGraphRelationalExprexecuteSchemaExprcommitrollbackplanForDatabaseContextExprtransactionGraphAsRelationheadTransactionIdheadNameatomTypesAsRelationdisconnectedTransactionIsDirtycallTestTimeout_transactionGraph_disconnectedTransaction_withTransaction"$fExceptionRequestTimeoutException%$fExceptionRemoteProcessDiedException $fShowRemoteProcessDiedException$fEqRemoteProcessDiedException$fShowRequestTimeoutException$fEqRequestTimeoutException$fBinaryEvaluatedNotification$fEqEvaluatedNotification$fShowEvaluatedNotification$fGenericEvaluatedNotification$fBinaryNotificationMessage$fEqNotificationMessage$fShowNotificationMessage$fGenericNotificationMessage$fShowConnectionError$fEqConnectionError$fGenericConnectionErrorDbError ConnErrorRelErrorTransactionRolledBackDbDbConnsimpleConnectProjectM36AtsimpleConnectProjectM36withTransactionUsingexecutequery executeOrErr queryOrErrcancelTransactionorCancelTransaction$fExceptionTransactionCancelled $fFunctorDb$fApplicativeDb $fMonadDb $fMonadIODb $fEqDbError $fShowDbError$fShowTransactionCancelled ServerConfigpersistenceStrategy databaseNamebindHostbindPort ghcPkgPathsperRequestTimeouttestModedefaultServerConfig$fShowServerConfigReplyTimeout timeoutOrDiehandleExecuteRelationalExpr handleExecuteDatabaseContextExpr"handleExecuteDatabaseContextIOExprhandleExecuteHeadName handleLoginhandleExecuteGraphExpr%handleExecuteTransGraphRelationalExpr"handleExecuteTypeForRelationalExpr#handleRetrieveInclusionDependencies(handleRetrievePlanForDatabaseContextExprhandleRetrieveTransactionGraphhandleRetrieveHeadTransactionIdhandleCreateSessionAtCommithandleCreateSessionAtHeadhandleCloseSession!handleRetrieveAtomTypesAsRelation%handleRetrieveRelationVariableSummaryhandleRetrieveCurrentSchemaNamehandleExecuteSchemaExpr handleLogouthandleTestTimeouthandleRetrieveSessionIsDirtyhandleExecuteAutoMergeToHead$handleRetrieveTypeConstructorMappingserverDefinition initServer registerDBloggingNotificationCallback launchServerparseArgsWithDefaultsparsePersistenceStrategyparseDatabaseName parseHostname parsePortparseGhcPkgPaths parseTimeout parseConfigparseConfigWithDefaultsshowTransactionStructureshowGraphStructure TupleableGtoTupleG toAttributesG fromTupleG TupleabletoTuple fromTuple toAttributes toInsertExpr toDefineExpr$fTupleableGU1$fTupleableGM1$fTupleableG:*:$fTupleableGM10$fTupleableGM11cHSDirectoryFsync atomicRename syncHandle syncDirectorydirectoryFsync ClientNodesNotificationMessage"processTransactionGraphPersistenceRemoteProcessConnectionConf rLocalNode rProcessId rTransportInProcessConnectionConfipPersistenceStrategy ipClientNodes ipSessionsipTransactionGraphipScriptSession ipLocalNode ipTransportipLocksEvaluatedNotifications GhcPkgPathcreateLocalNodenotificationListenerstartNotificationListenercreateScriptSessionconnectPersistentProjectM36createSessionAtCommit_ excEitherrunProcessResult safeLogin remoteCallsessionForSessionIdschemaForSessionIdsessionAndSchemaexecuteCommitExprSTM_sendNotificationsreadGraphTransactionIdDigesttypeForRelationalExprSTM headNameSTM_ commitLock_base Data.EitherEitherTransactionCancelledrunDb