2020-05-20 18:38:46 +03:00
|
|
|
package idris2
|
2021-09-19 22:53:32 +03:00
|
|
|
version = 0.5.1
|
2020-05-20 18:38:46 +03:00
|
|
|
|
|
|
|
|
modules =
|
|
|
|
|
Algebra,
|
|
|
|
|
Algebra.Preorder,
|
|
|
|
|
Algebra.Semiring,
|
|
|
|
|
Algebra.ZeroOneOmega,
|
|
|
|
|
|
|
|
|
|
Compiler.ANF,
|
2021-04-29 15:44:13 +03:00
|
|
|
Compiler.CaseOpts,
|
2020-05-20 18:38:46 +03:00
|
|
|
Compiler.Common,
|
|
|
|
|
Compiler.CompileExpr,
|
2021-07-04 06:52:29 +03:00
|
|
|
Compiler.Generated,
|
2020-05-20 18:38:46 +03:00
|
|
|
Compiler.Inline,
|
|
|
|
|
Compiler.LambdaLift,
|
2021-11-09 19:23:50 +03:00
|
|
|
Compiler.NoMangle,
|
2021-09-02 08:47:35 +03:00
|
|
|
Compiler.Opts.CSE,
|
2021-05-11 10:20:19 +03:00
|
|
|
Compiler.Separate,
|
2020-07-10 12:03:21 +03:00
|
|
|
Compiler.VMCode,
|
|
|
|
|
|
2021-10-07 21:21:32 +03:00
|
|
|
Compiler.Opts.ConstantFold,
|
|
|
|
|
Compiler.Opts.Identity,
|
|
|
|
|
Compiler.Opts.InlineHeuristics,
|
|
|
|
|
|
2021-07-10 13:15:21 +03:00
|
|
|
Compiler.ES.Ast,
|
|
|
|
|
Compiler.ES.Codegen,
|
|
|
|
|
Compiler.ES.Doc,
|
2020-07-10 12:03:21 +03:00
|
|
|
Compiler.ES.Javascript,
|
|
|
|
|
Compiler.ES.Node,
|
2021-07-10 13:15:21 +03:00
|
|
|
Compiler.ES.State,
|
2020-07-10 12:03:21 +03:00
|
|
|
Compiler.ES.TailRec,
|
2021-07-10 13:15:21 +03:00
|
|
|
Compiler.ES.ToAst,
|
2020-07-10 12:03:21 +03:00
|
|
|
|
2021-07-07 19:06:59 +03:00
|
|
|
Compiler.Interpreter.VMCode,
|
|
|
|
|
|
2021-06-17 19:23:29 +03:00
|
|
|
Compiler.RefC,
|
2021-04-14 14:24:32 +03:00
|
|
|
Compiler.RefC.CC,
|
2020-10-11 17:05:00 +03:00
|
|
|
Compiler.RefC.RefC,
|
|
|
|
|
|
2020-05-20 18:38:46 +03:00
|
|
|
Compiler.Scheme.Chez,
|
2021-05-11 10:20:19 +03:00
|
|
|
Compiler.Scheme.ChezSep,
|
2020-05-20 18:38:46 +03:00
|
|
|
Compiler.Scheme.Racket,
|
|
|
|
|
Compiler.Scheme.Gambit,
|
|
|
|
|
Compiler.Scheme.Common,
|
|
|
|
|
|
|
|
|
|
Core.AutoSearch,
|
|
|
|
|
Core.Binary,
|
2021-09-07 01:37:59 +03:00
|
|
|
Core.Binary.Prims,
|
2021-10-02 14:55:21 +03:00
|
|
|
Core.Case.CaseBuilder,
|
|
|
|
|
Core.Case.CaseTree,
|
|
|
|
|
Core.Case.Util,
|
2020-05-20 18:38:46 +03:00
|
|
|
Core.CompileExpr,
|
2020-07-10 12:03:21 +03:00
|
|
|
Core.Context,
|
2021-09-07 01:37:59 +03:00
|
|
|
Core.Context.Context,
|
2020-09-15 16:41:55 +03:00
|
|
|
Core.Context.Data,
|
|
|
|
|
Core.Context.Log,
|
2020-05-20 18:38:46 +03:00
|
|
|
Core.Core,
|
|
|
|
|
Core.Coverage,
|
|
|
|
|
Core.Directory,
|
|
|
|
|
Core.Env,
|
|
|
|
|
Core.FC,
|
|
|
|
|
Core.GetType,
|
|
|
|
|
Core.Hash,
|
|
|
|
|
Core.InitPrimitives,
|
|
|
|
|
Core.LinearCheck,
|
|
|
|
|
Core.Metadata,
|
|
|
|
|
Core.Name,
|
2020-09-05 11:41:31 +03:00
|
|
|
Core.Name.Namespace,
|
2020-05-20 18:38:46 +03:00
|
|
|
Core.Normalise,
|
Speculative normalisation (#1902)
* Split Normalise into three files
Evaluation, Quoting, and Conversion checking are distinct steps, and I'm
about to add some variations to quoting so better to reorganise a bit.
* Add a Quote mode that limits size of result
Sometimes normalising an expression is a good idea because it makes
things smaler, and sometimes it isnt, because it doesn't. We can't tell
in advance which situation we're in, but we can try speculatively
normalising something. This is good for case types and hole types - we
generally want the normal form, but if that's expensive, we should stop.
So, quote is now able to give up if it passes a certain size threshold
for stuck applications. By experimentation, it seems that up to 10
doesn't hurt too much, but beyond that it's better not to normalise at
all.
* Add the new normalise files
2021-09-05 03:35:21 +03:00
|
|
|
Core.Normalise.Convert,
|
|
|
|
|
Core.Normalise.Eval,
|
|
|
|
|
Core.Normalise.Quote,
|
2020-05-20 18:38:46 +03:00
|
|
|
Core.Options,
|
2020-08-20 20:45:34 +03:00
|
|
|
Core.Options.Log,
|
2021-09-02 08:47:35 +03:00
|
|
|
Core.Ord,
|
2020-05-20 18:38:46 +03:00
|
|
|
Core.Primitives,
|
2020-05-30 00:40:29 +03:00
|
|
|
Core.Reflect,
|
Experimental Scheme based evaluator (#1956)
This is for compiled evaluation at compile-time, for full normalisation. You can try it by setting the evaluation mode to scheme (that is, :set eval scheme at the REPL). It's certainly an order of magnitude faster than the standard evaluator, based on my playing around with it, although still quite a bit slower than compilation for various reasons, including:
* It has to evaluate under binders, and therefore deal with blocked symbols
* It has to maintain enough information to be able to read back a Term from the evaluated scheme object, which means retaining things like types and other metadata
* We can't do a lot of the optimisations we'd do for runtime evaluation particularly setting things up so we don't need to do arity checking
Also added a new option evaltiming (set with :set evaltiming) to display how long evaluation itself takes, which is handy for checking performance.
I also don't think we should aim to replace the standard evaluator, in general, at least not for a while, because that will involve rewriting a lot of things and working out how to make it work as Call By Name (which is clearly possible, but fiddly).
Still, it's going to be interesting to experiment with it! I think it will be a good idea to use it for elaborator reflection and type providers when we eventually get around to implementing them.
Original commit details:
* Add ability to evaluate open terms via Scheme
Still lots of polish and more formal testing to do here before we can
use it in practice, but you can still use ':scheme <term>' at the REPL
to evaluate an expression by compiling to scheme then reading back the
result.
Also added 'evaltiming' option at the REPL, which, when set, displays
how long normalisaton takes (doesn't count resugaring, just the
normalisation step).
* Add scheme evaluation mode
Different when evaluating everything, vs only evaluating visible things.
We want the latter when type checking, the former at the REPL.
* Bring support.rkt up to date
A couple of missing things required for interfacing with scheme objects
* More Scheme readback machinery
We need these things in the next version so that the next-but-one
version can have a scheme evaluator!
* Add top level interface to scheme based normaliser
Also check it's available - currently chez only - and revert to the
default slow normaliser if it's not.
* Bring Context up to date with changes in main
* Now need Idris 0.5.0 to build
* Add SNF type for scheme values
This will allow us to incrementally evaluate under lambdas, which will
be useful for elaborator reflection and type providers.
* Add Quote for scheme evaluator
So, we can now get a weak head normal form, and evaluate the scope of
a binder when we have an argument to plug in, or just quote back the
whole thing.
* Add new 'scheme' evaluator mode at the REPL
Replacing the temporary 'TmpScheme', this is a better way to try out the
scheme based evaluator
* Fix name generation for new UN format
* Add scheme evaluator support to Racket
* Add another scheme eval test
With metavariables this time
* evaltiming now times execution too
This was handy for finding out the difference between the scheme based
evaluator and compilation. Compilation was something like 20 times
faster in my little test, so that'd be about 4-500 times faster than the
standard evaluator. Ouch!
* Fix whitespace errors
* Error handling when trying to evaluate Scheme
2021-09-24 22:38:55 +03:00
|
|
|
Core.SchemeEval,
|
2020-05-20 18:38:46 +03:00
|
|
|
Core.Termination,
|
|
|
|
|
Core.Transform,
|
|
|
|
|
Core.TT,
|
2021-10-13 13:12:05 +03:00
|
|
|
Core.TT.Traversals,
|
2020-05-20 18:38:46 +03:00
|
|
|
Core.TTC,
|
|
|
|
|
Core.Unify,
|
|
|
|
|
Core.UnifyState,
|
|
|
|
|
Core.Value,
|
|
|
|
|
|
Experimental Scheme based evaluator (#1956)
This is for compiled evaluation at compile-time, for full normalisation. You can try it by setting the evaluation mode to scheme (that is, :set eval scheme at the REPL). It's certainly an order of magnitude faster than the standard evaluator, based on my playing around with it, although still quite a bit slower than compilation for various reasons, including:
* It has to evaluate under binders, and therefore deal with blocked symbols
* It has to maintain enough information to be able to read back a Term from the evaluated scheme object, which means retaining things like types and other metadata
* We can't do a lot of the optimisations we'd do for runtime evaluation particularly setting things up so we don't need to do arity checking
Also added a new option evaltiming (set with :set evaltiming) to display how long evaluation itself takes, which is handy for checking performance.
I also don't think we should aim to replace the standard evaluator, in general, at least not for a while, because that will involve rewriting a lot of things and working out how to make it work as Call By Name (which is clearly possible, but fiddly).
Still, it's going to be interesting to experiment with it! I think it will be a good idea to use it for elaborator reflection and type providers when we eventually get around to implementing them.
Original commit details:
* Add ability to evaluate open terms via Scheme
Still lots of polish and more formal testing to do here before we can
use it in practice, but you can still use ':scheme <term>' at the REPL
to evaluate an expression by compiling to scheme then reading back the
result.
Also added 'evaltiming' option at the REPL, which, when set, displays
how long normalisaton takes (doesn't count resugaring, just the
normalisation step).
* Add scheme evaluation mode
Different when evaluating everything, vs only evaluating visible things.
We want the latter when type checking, the former at the REPL.
* Bring support.rkt up to date
A couple of missing things required for interfacing with scheme objects
* More Scheme readback machinery
We need these things in the next version so that the next-but-one
version can have a scheme evaluator!
* Add top level interface to scheme based normaliser
Also check it's available - currently chez only - and revert to the
default slow normaliser if it's not.
* Bring Context up to date with changes in main
* Now need Idris 0.5.0 to build
* Add SNF type for scheme values
This will allow us to incrementally evaluate under lambdas, which will
be useful for elaborator reflection and type providers.
* Add Quote for scheme evaluator
So, we can now get a weak head normal form, and evaluate the scope of
a binder when we have an argument to plug in, or just quote back the
whole thing.
* Add new 'scheme' evaluator mode at the REPL
Replacing the temporary 'TmpScheme', this is a better way to try out the
scheme based evaluator
* Fix name generation for new UN format
* Add scheme evaluator support to Racket
* Add another scheme eval test
With metavariables this time
* evaltiming now times execution too
This was handy for finding out the difference between the scheme based
evaluator and compilation. Compilation was something like 20 times
faster in my little test, so that'd be about 4-500 times faster than the
standard evaluator. Ouch!
* Fix whitespace errors
* Error handling when trying to evaluate Scheme
2021-09-24 22:38:55 +03:00
|
|
|
Core.SchemeEval.Builtins,
|
|
|
|
|
Core.SchemeEval.Compile,
|
|
|
|
|
Core.SchemeEval.Evaluate,
|
|
|
|
|
Core.SchemeEval.Quote,
|
|
|
|
|
Core.SchemeEval.ToScheme,
|
|
|
|
|
|
2020-05-20 18:38:46 +03:00
|
|
|
IdrisPaths,
|
|
|
|
|
|
|
|
|
|
Idris.CommandLine,
|
|
|
|
|
Idris.Desugar,
|
2021-05-14 19:35:21 +03:00
|
|
|
Idris.Desugar.Mutual,
|
2021-01-17 10:56:53 +03:00
|
|
|
Idris.Env,
|
2021-10-26 20:58:06 +03:00
|
|
|
Idris.Doc.Annotations,
|
|
|
|
|
Idris.Doc.Keywords,
|
2021-04-29 12:29:37 +03:00
|
|
|
Idris.Doc.HTML,
|
2021-05-21 13:37:08 +03:00
|
|
|
Idris.Doc.String,
|
2020-06-14 15:55:06 +03:00
|
|
|
Idris.Driver,
|
2020-05-20 18:38:46 +03:00
|
|
|
Idris.Error,
|
|
|
|
|
Idris.ModTree,
|
2021-04-15 16:08:50 +03:00
|
|
|
|
2020-05-20 18:38:46 +03:00
|
|
|
Idris.Package,
|
2021-04-15 16:08:50 +03:00
|
|
|
Idris.Package.Init,
|
|
|
|
|
Idris.Package.Types,
|
|
|
|
|
|
2020-05-20 18:38:46 +03:00
|
|
|
Idris.Parser,
|
2020-09-28 15:15:22 +03:00
|
|
|
Idris.Parser.Let,
|
2020-07-22 22:16:43 +03:00
|
|
|
Idris.Pretty,
|
2021-04-21 11:39:18 +03:00
|
|
|
Idris.Pretty.Render,
|
2020-05-20 18:38:46 +03:00
|
|
|
Idris.ProcessIdr,
|
|
|
|
|
Idris.REPL,
|
|
|
|
|
Idris.Resugar,
|
|
|
|
|
Idris.SetOptions,
|
|
|
|
|
Idris.Syntax,
|
|
|
|
|
Idris.Version,
|
|
|
|
|
|
2020-07-10 12:03:21 +03:00
|
|
|
Idris.Elab.Implementation,
|
|
|
|
|
Idris.Elab.Interface,
|
|
|
|
|
|
|
|
|
|
Idris.IDEMode.CaseSplit,
|
|
|
|
|
Idris.IDEMode.Commands,
|
|
|
|
|
Idris.IDEMode.Holes,
|
|
|
|
|
Idris.IDEMode.MakeClause,
|
|
|
|
|
Idris.IDEMode.Parser,
|
2021-12-17 01:09:00 +03:00
|
|
|
Idris.IDEMode.Pretty,
|
2020-07-10 12:03:21 +03:00
|
|
|
Idris.IDEMode.REPL,
|
|
|
|
|
Idris.IDEMode.SyntaxHighlight,
|
|
|
|
|
Idris.IDEMode.TokenLine,
|
|
|
|
|
|
2021-04-25 11:13:55 +03:00
|
|
|
Idris.REPL.Common,
|
|
|
|
|
Idris.REPL.Opts,
|
|
|
|
|
Idris.REPL.FuzzySearch,
|
|
|
|
|
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Control.ANSI,
|
|
|
|
|
Libraries.Control.ANSI.CSI,
|
|
|
|
|
Libraries.Control.ANSI.SGR,
|
|
|
|
|
Libraries.Control.Delayed,
|
|
|
|
|
|
|
|
|
|
Libraries.Data.ANameMap,
|
|
|
|
|
Libraries.Data.DList,
|
2021-06-14 12:59:49 +03:00
|
|
|
Libraries.Data.Fin,
|
2021-06-17 14:43:10 +03:00
|
|
|
Libraries.Data.Graph,
|
2021-02-25 11:51:27 +03:00
|
|
|
Libraries.Data.IMaybe,
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Data.IntMap,
|
2021-07-15 02:38:08 +03:00
|
|
|
Libraries.Data.IOArray,
|
2021-03-29 12:45:48 +03:00
|
|
|
Libraries.Data.IOMatrix,
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Data.LengthMatch,
|
|
|
|
|
Libraries.Data.List.Extra,
|
2021-10-26 20:58:06 +03:00
|
|
|
Libraries.Data.List.Quantifiers.Extra,
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Data.List.Lazy,
|
2021-03-04 22:09:15 +03:00
|
|
|
Libraries.Data.List1,
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Data.NameMap,
|
2021-11-09 19:23:50 +03:00
|
|
|
Libraries.Data.NameMap.Traversable,
|
2021-03-17 19:29:05 +03:00
|
|
|
Libraries.Data.PosMap,
|
2021-10-08 14:07:11 +03:00
|
|
|
Libraries.Data.Primitives,
|
2021-12-17 01:09:00 +03:00
|
|
|
Libraries.Data.Span,
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Data.SortedMap,
|
|
|
|
|
Libraries.Data.SortedSet,
|
|
|
|
|
Libraries.Data.String.Extra,
|
|
|
|
|
Libraries.Data.String.Iterator,
|
|
|
|
|
Libraries.Data.StringMap,
|
|
|
|
|
Libraries.Data.StringTrie,
|
2021-09-15 15:20:58 +03:00
|
|
|
Libraries.Data.UserNameMap,
|
2021-06-15 16:31:31 +03:00
|
|
|
Libraries.Data.Version,
|
2020-12-31 04:05:22 +03:00
|
|
|
|
2021-04-15 16:08:50 +03:00
|
|
|
Libraries.System.Directory.Tree,
|
|
|
|
|
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Text.Bounded,
|
2021-03-29 12:45:48 +03:00
|
|
|
Libraries.Text.Distance.Levenshtein,
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Text.Lexer,
|
|
|
|
|
Libraries.Text.Lexer.Core,
|
2021-02-05 12:15:13 +03:00
|
|
|
Libraries.Text.Lexer.Tokenizer,
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Text.Literate,
|
|
|
|
|
Libraries.Text.Parser,
|
|
|
|
|
Libraries.Text.Parser.Core,
|
|
|
|
|
Libraries.Text.PrettyPrint.Prettyprinter,
|
|
|
|
|
Libraries.Text.PrettyPrint.Prettyprinter.Doc,
|
2021-04-20 22:50:37 +03:00
|
|
|
Libraries.Text.PrettyPrint.Prettyprinter.Render.HTML,
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Text.PrettyPrint.Prettyprinter.Render.String,
|
|
|
|
|
Libraries.Text.PrettyPrint.Prettyprinter.Render.Terminal,
|
|
|
|
|
Libraries.Text.PrettyPrint.Prettyprinter.SimpleDocTree,
|
|
|
|
|
Libraries.Text.PrettyPrint.Prettyprinter.Symbols,
|
|
|
|
|
Libraries.Text.PrettyPrint.Prettyprinter.Util,
|
|
|
|
|
Libraries.Text.Quantity,
|
|
|
|
|
Libraries.Text.Token,
|
|
|
|
|
|
|
|
|
|
Libraries.Utils.Binary,
|
|
|
|
|
Libraries.Utils.Octal,
|
|
|
|
|
Libraries.Utils.Path,
|
Experimental Scheme based evaluator (#1956)
This is for compiled evaluation at compile-time, for full normalisation. You can try it by setting the evaluation mode to scheme (that is, :set eval scheme at the REPL). It's certainly an order of magnitude faster than the standard evaluator, based on my playing around with it, although still quite a bit slower than compilation for various reasons, including:
* It has to evaluate under binders, and therefore deal with blocked symbols
* It has to maintain enough information to be able to read back a Term from the evaluated scheme object, which means retaining things like types and other metadata
* We can't do a lot of the optimisations we'd do for runtime evaluation particularly setting things up so we don't need to do arity checking
Also added a new option evaltiming (set with :set evaltiming) to display how long evaluation itself takes, which is handy for checking performance.
I also don't think we should aim to replace the standard evaluator, in general, at least not for a while, because that will involve rewriting a lot of things and working out how to make it work as Call By Name (which is clearly possible, but fiddly).
Still, it's going to be interesting to experiment with it! I think it will be a good idea to use it for elaborator reflection and type providers when we eventually get around to implementing them.
Original commit details:
* Add ability to evaluate open terms via Scheme
Still lots of polish and more formal testing to do here before we can
use it in practice, but you can still use ':scheme <term>' at the REPL
to evaluate an expression by compiling to scheme then reading back the
result.
Also added 'evaltiming' option at the REPL, which, when set, displays
how long normalisaton takes (doesn't count resugaring, just the
normalisation step).
* Add scheme evaluation mode
Different when evaluating everything, vs only evaluating visible things.
We want the latter when type checking, the former at the REPL.
* Bring support.rkt up to date
A couple of missing things required for interfacing with scheme objects
* More Scheme readback machinery
We need these things in the next version so that the next-but-one
version can have a scheme evaluator!
* Add top level interface to scheme based normaliser
Also check it's available - currently chez only - and revert to the
default slow normaliser if it's not.
* Bring Context up to date with changes in main
* Now need Idris 0.5.0 to build
* Add SNF type for scheme values
This will allow us to incrementally evaluate under lambdas, which will
be useful for elaborator reflection and type providers.
* Add Quote for scheme evaluator
So, we can now get a weak head normal form, and evaluate the scope of
a binder when we have an argument to plug in, or just quote back the
whole thing.
* Add new 'scheme' evaluator mode at the REPL
Replacing the temporary 'TmpScheme', this is a better way to try out the
scheme based evaluator
* Fix name generation for new UN format
* Add scheme evaluator support to Racket
* Add another scheme eval test
With metavariables this time
* evaltiming now times execution too
This was handy for finding out the difference between the scheme based
evaluator and compilation. Compilation was something like 20 times
faster in my little test, so that'd be about 4-500 times faster than the
standard evaluator. Ouch!
* Fix whitespace errors
* Error handling when trying to evaluate Scheme
2021-09-24 22:38:55 +03:00
|
|
|
Libraries.Utils.Scheme,
|
2020-12-31 04:05:22 +03:00
|
|
|
Libraries.Utils.Shunting,
|
|
|
|
|
Libraries.Utils.String,
|
|
|
|
|
Libraries.Utils.Term,
|
|
|
|
|
|
2020-07-10 12:03:21 +03:00
|
|
|
Parser.Package,
|
|
|
|
|
Parser.Source,
|
|
|
|
|
Parser.Support,
|
|
|
|
|
Parser.Unlit,
|
|
|
|
|
|
2020-05-20 23:27:50 +03:00
|
|
|
Parser.Lexer.Common,
|
2020-05-21 06:25:25 +03:00
|
|
|
Parser.Lexer.Package,
|
2020-05-20 21:47:13 +03:00
|
|
|
Parser.Lexer.Source,
|
2020-07-10 12:03:21 +03:00
|
|
|
|
2020-05-21 06:25:25 +03:00
|
|
|
Parser.Rule.Package,
|
2020-05-20 21:53:50 +03:00
|
|
|
Parser.Rule.Source,
|
2020-07-10 12:03:21 +03:00
|
|
|
|
2021-12-17 01:09:00 +03:00
|
|
|
Protocol.IDE,
|
|
|
|
|
Protocol.IDE.Command,
|
|
|
|
|
Protocol.IDE.Decoration,
|
|
|
|
|
Protocol.IDE.FileContext,
|
|
|
|
|
Protocol.IDE.Formatting,
|
|
|
|
|
Protocol.IDE.Holes,
|
|
|
|
|
Protocol.IDE.Result,
|
|
|
|
|
Protocol.IDE.Highlight,
|
|
|
|
|
Protocol.Hex,
|
|
|
|
|
Protocol.SExp,
|
2022-01-06 13:09:29 +03:00
|
|
|
Protocol.SExp.Parser,
|
2021-12-17 01:09:00 +03:00
|
|
|
|
2020-05-20 18:38:46 +03:00
|
|
|
TTImp.BindImplicits,
|
|
|
|
|
TTImp.Elab,
|
2020-07-10 12:03:21 +03:00
|
|
|
TTImp.Impossible,
|
|
|
|
|
TTImp.Parser,
|
|
|
|
|
TTImp.PartialEval,
|
2021-04-22 15:08:32 +03:00
|
|
|
TTImp.ProcessBuiltin,
|
2020-07-10 12:03:21 +03:00
|
|
|
TTImp.ProcessData,
|
|
|
|
|
TTImp.ProcessDecls,
|
|
|
|
|
TTImp.ProcessDef,
|
|
|
|
|
TTImp.ProcessParams,
|
|
|
|
|
TTImp.ProcessRecord,
|
|
|
|
|
TTImp.ProcessRunElab,
|
|
|
|
|
TTImp.ProcessTransform,
|
|
|
|
|
TTImp.ProcessType,
|
|
|
|
|
TTImp.Reflect,
|
|
|
|
|
TTImp.TTImp,
|
2021-08-13 18:00:54 +03:00
|
|
|
TTImp.TTImp.Functor,
|
2020-07-10 12:03:21 +03:00
|
|
|
TTImp.Unelab,
|
|
|
|
|
TTImp.Utils,
|
|
|
|
|
TTImp.WithClause,
|
|
|
|
|
|
2020-05-20 18:38:46 +03:00
|
|
|
TTImp.Elab.Ambiguity,
|
|
|
|
|
TTImp.Elab.App,
|
|
|
|
|
TTImp.Elab.As,
|
|
|
|
|
TTImp.Elab.Binders,
|
|
|
|
|
TTImp.Elab.Case,
|
|
|
|
|
TTImp.Elab.Check,
|
|
|
|
|
TTImp.Elab.Delayed,
|
|
|
|
|
TTImp.Elab.Dot,
|
|
|
|
|
TTImp.Elab.Hole,
|
|
|
|
|
TTImp.Elab.ImplicitBind,
|
|
|
|
|
TTImp.Elab.Lazy,
|
|
|
|
|
TTImp.Elab.Local,
|
|
|
|
|
TTImp.Elab.Prim,
|
2020-05-30 00:40:29 +03:00
|
|
|
TTImp.Elab.Quote,
|
2020-05-20 18:38:46 +03:00
|
|
|
TTImp.Elab.Record,
|
|
|
|
|
TTImp.Elab.Rewrite,
|
2020-06-14 15:55:06 +03:00
|
|
|
TTImp.Elab.RunElab,
|
2020-05-20 18:38:46 +03:00
|
|
|
TTImp.Elab.Term,
|
|
|
|
|
TTImp.Elab.Utils,
|
2020-07-10 12:03:21 +03:00
|
|
|
|
2020-05-20 18:38:46 +03:00
|
|
|
TTImp.Interactive.CaseSplit,
|
|
|
|
|
TTImp.Interactive.ExprSearch,
|
|
|
|
|
TTImp.Interactive.GenerateDef,
|
|
|
|
|
TTImp.Interactive.MakeLemma,
|
|
|
|
|
|
|
|
|
|
Yaffle.Main,
|
|
|
|
|
Yaffle.REPL
|
|
|
|
|
|
2020-12-31 04:05:22 +03:00
|
|
|
depends = network
|
2020-05-20 18:38:46 +03:00
|
|
|
|
|
|
|
|
sourcedir = "src"
|
