summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorAndresSicardRamirez <>2016-12-22 12:39:00 (GMT)
committerhdiff <hdiff@hdiff.luite.com>2016-12-22 12:39:00 (GMT)
commit183a416a313dcf31702dfde1a50306ea4f923060 (patch)
tree2125b6a38d46354f7ec22b1ba02adfdb13821a81
parent943f54b053c0702c851e5508e36adb55ba934444 (diff)
version 2.5.22.5.2
-rw-r--r--Agda.cabal259
-rw-r--r--CHANGELOG6677
-rw-r--r--CHANGELOG.md8782
-rw-r--r--README.md11
-rw-r--r--dist/build/Agda/Syntax/Parser/Lexer.hs633
-rw-r--r--dist/build/Agda/Syntax/Parser/Parser.hs4606
-rw-r--r--src/agda-ghc-names/ExtractNames.hs152
-rw-r--r--src/agda-ghc-names/Find.hs50
-rw-r--r--src/agda-ghc-names/FixProf.hs118
-rw-r--r--src/agda-ghc-names/ResolveHsNames.hs82
-rw-r--r--src/agda-ghc-names/agda-ghc-names.hs49
-rw-r--r--src/data/JS/agda-rts.js172
-rw-r--r--src/data/JS/biginteger.js1620
-rw-r--r--src/data/MAlonzo/src/MAlonzo/RTE.hs73
-rw-r--r--src/data/agda.sty173
-rw-r--r--src/data/emacs-mode/agda-input.el68
-rw-r--r--src/data/emacs-mode/agda2-abbrevs.el12
-rw-r--r--src/data/emacs-mode/agda2-highlight.el11
-rw-r--r--src/data/emacs-mode/agda2-mode-pkg.el2
-rw-r--r--src/data/emacs-mode/agda2-mode.el332
-rw-r--r--src/data/lib/prim/Agda/Builtin/Bool.agda2
-rw-r--r--src/data/lib/prim/Agda/Builtin/Char.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/Coinduction.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/Equality.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/Float.agda11
-rw-r--r--src/data/lib/prim/Agda/Builtin/FromNat.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/FromNeg.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/FromString.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/IO.agda2
-rw-r--r--src/data/lib/prim/Agda/Builtin/Int.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/List.agda7
-rw-r--r--src/data/lib/prim/Agda/Builtin/Nat.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/Reflection.agda44
-rw-r--r--src/data/lib/prim/Agda/Builtin/Size.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/Strict.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/String.agda8
-rw-r--r--src/data/lib/prim/Agda/Builtin/TrustMe.agda1
-rw-r--r--src/data/lib/prim/Agda/Builtin/Unit.agda1
-rw-r--r--src/data/lib/prim/Agda/Primitive.agda2
-rw-r--r--src/data/uhc-agda-base/src/UHC/Agda/Builtins.hs81
-rw-r--r--src/data/uhc-agda-base/src/UHC/Agda/double.c12
-rw-r--r--src/data/uhc-agda-base/src/UHC/Agda/double.h2
-rw-r--r--src/full/Agda/Auto/Auto.hs22
-rw-r--r--src/full/Agda/Auto/CaseSplit.hs1
-rw-r--r--src/full/Agda/Auto/Convert.hs135
-rw-r--r--src/full/Agda/Auto/NarrowingSearch.hs5
-rw-r--r--src/full/Agda/Auto/SearchControl.hs2
-rw-r--r--src/full/Agda/Auto/Syntax.hs1
-rw-r--r--src/full/Agda/Auto/Typecheck.hs2
-rw-r--r--src/full/Agda/Benchmarking.hs14
-rw-r--r--src/full/Agda/Compiler/CallCompiler.hs6
-rw-r--r--src/full/Agda/Compiler/Common.hs4
-rw-r--r--src/full/Agda/Compiler/Epic/Compiler.hs5
-rw-r--r--src/full/Agda/Compiler/Epic/Forcing.hs9
-rw-r--r--src/full/Agda/Compiler/Epic/FromAgda.hs5
-rw-r--r--src/full/Agda/Compiler/Epic/Injection.hs24
-rw-r--r--src/full/Agda/Compiler/Epic/Interface.hs31
-rw-r--r--src/full/Agda/Compiler/Epic/Primitive.hs2
-rw-r--r--src/full/Agda/Compiler/Epic/Static.hs13
-rw-r--r--src/full/Agda/Compiler/HaskellTypes.hs2
-rw-r--r--src/full/Agda/Compiler/JS/Case.hs127
-rw-r--r--src/full/Agda/Compiler/JS/Compiler.hs533
-rw-r--r--src/full/Agda/Compiler/JS/Parser.hs185
-rw-r--r--src/full/Agda/Compiler/JS/Pretty.hs30
-rw-r--r--src/full/Agda/Compiler/JS/Syntax.hs13
-rw-r--r--src/full/Agda/Compiler/MAlonzo/Compiler.hs283
-rw-r--r--src/full/Agda/Compiler/MAlonzo/Compiler.hs-boot2
-rw-r--r--src/full/Agda/Compiler/MAlonzo/Encode.hs77
-rw-r--r--src/full/Agda/Compiler/MAlonzo/Misc.hs59
-rw-r--r--src/full/Agda/Compiler/MAlonzo/Pretty.hs218
-rw-r--r--src/full/Agda/Compiler/MAlonzo/Primitives.hs87
-rw-r--r--src/full/Agda/Compiler/ToTreeless.hs60
-rw-r--r--src/full/Agda/Compiler/Treeless/AsPatterns.hs83
-rw-r--r--src/full/Agda/Compiler/Treeless/Builtin.hs24
-rw-r--r--src/full/Agda/Compiler/Treeless/Compare.hs7
-rw-r--r--src/full/Agda/Compiler/Treeless/DelayCoinduction.hs69
-rw-r--r--src/full/Agda/Compiler/Treeless/EliminateLiteralPatterns.hs79
-rw-r--r--src/full/Agda/Compiler/Treeless/Erase.hs68
-rw-r--r--src/full/Agda/Compiler/Treeless/GuardsToPrims.hs10
-rw-r--r--src/full/Agda/Compiler/Treeless/Identity.hs102
-rw-r--r--src/full/Agda/Compiler/Treeless/Pretty.hs14
-rw-r--r--src/full/Agda/Compiler/Treeless/Simplify.hs83
-rw-r--r--src/full/Agda/Compiler/Treeless/Subst.hs19
-rw-r--r--src/full/Agda/Compiler/Treeless/Uncase.hs3
-rw-r--r--src/full/Agda/Compiler/Treeless/Unused.hs13
-rw-r--r--src/full/Agda/Compiler/UHC/Bridge.hs2
-rw-r--r--src/full/Agda/Compiler/UHC/CompileState.hs11
-rw-r--r--src/full/Agda/Compiler/UHC/Compiler.hs29
-rw-r--r--src/full/Agda/Compiler/UHC/FromAgda.hs24
-rw-r--r--src/full/Agda/Compiler/UHC/Primitives.hs14
-rw-r--r--src/full/Agda/Compiler/UHC/Smashing.hs164
-rw-r--r--src/full/Agda/Interaction/BasicOps.hs150
-rw-r--r--src/full/Agda/Interaction/CommandLine.hs8
-rw-r--r--src/full/Agda/Interaction/EmacsCommand.hs29
-rw-r--r--src/full/Agda/Interaction/EmacsTop.hs34
-rw-r--r--src/full/Agda/Interaction/Exceptions.hs21
-rw-r--r--src/full/Agda/Interaction/FindFile.hs116
-rw-r--r--src/full/Agda/Interaction/FindFile.hs-boot7
-rw-r--r--src/full/Agda/Interaction/Highlighting/Emacs.hs12
-rw-r--r--src/full/Agda/Interaction/Highlighting/Generate.hs75
-rw-r--r--src/full/Agda/Interaction/Highlighting/LaTeX.hs166
-rw-r--r--src/full/Agda/Interaction/Highlighting/Precise.hs186
-rw-r--r--src/full/Agda/Interaction/Highlighting/Range.hs40
-rw-r--r--src/full/Agda/Interaction/Imports.hs560
-rw-r--r--src/full/Agda/Interaction/InteractionTop.hs347
-rw-r--r--src/full/Agda/Interaction/Library.hs20
-rw-r--r--src/full/Agda/Interaction/Library/Parse.hs6
-rw-r--r--src/full/Agda/Interaction/MakeCase.hs253
-rw-r--r--src/full/Agda/Interaction/Options.hs84
-rw-r--r--src/full/Agda/Interaction/Response.hs6
-rw-r--r--src/full/Agda/Interaction/SearchAbout.hs6
-rw-r--r--src/full/Agda/Main.hs50
-rw-r--r--src/full/Agda/Syntax/Abstract.hs275
-rw-r--r--src/full/Agda/Syntax/Abstract/Copatterns.hs55
-rw-r--r--src/full/Agda/Syntax/Abstract/Name.hs52
-rw-r--r--src/full/Agda/Syntax/Abstract/Pretty.hs1
-rw-r--r--src/full/Agda/Syntax/Abstract/Views.hs33
-rw-r--r--src/full/Agda/Syntax/Common.hs188
-rw-r--r--src/full/Agda/Syntax/Concrete.hs66
-rw-r--r--src/full/Agda/Syntax/Concrete/Definitions.hs1034
-rw-r--r--src/full/Agda/Syntax/Concrete/Generic.hs4
-rw-r--r--src/full/Agda/Syntax/Concrete/Name.hs57
-rw-r--r--src/full/Agda/Syntax/Concrete/Operators.hs101
-rw-r--r--src/full/Agda/Syntax/Concrete/Operators/Parser.hs101
-rw-r--r--src/full/Agda/Syntax/Concrete/Operators/Parser/Monad.hs100
-rw-r--r--src/full/Agda/Syntax/Concrete/Pretty.hs53
-rw-r--r--src/full/Agda/Syntax/Fixity.hs37
-rw-r--r--src/full/Agda/Syntax/IdiomBrackets.hs48
-rw-r--r--src/full/Agda/Syntax/Info.hs10
-rw-r--r--src/full/Agda/Syntax/Internal.hs326
-rw-r--r--src/full/Agda/Syntax/Internal/Defs.hs9
-rw-r--r--src/full/Agda/Syntax/Internal/Generic.hs12
-rw-r--r--src/full/Agda/Syntax/Internal/Names.hs18
-rw-r--r--src/full/Agda/Syntax/Internal/Pattern.hs104
-rw-r--r--src/full/Agda/Syntax/Internal/SanityCheck.hs72
-rw-r--r--src/full/Agda/Syntax/Literal.hs27
-rw-r--r--src/full/Agda/Syntax/Parser.hs151
-rw-r--r--src/full/Agda/Syntax/Parser/LexActions.hs2
-rw-r--r--src/full/Agda/Syntax/Parser/Lexer.x23
-rw-r--r--src/full/Agda/Syntax/Parser/Literate.hs219
-rw-r--r--src/full/Agda/Syntax/Parser/LookAhead.hs1
-rw-r--r--src/full/Agda/Syntax/Parser/Monad.hs113
-rw-r--r--src/full/Agda/Syntax/Parser/Parser.y121
-rw-r--r--src/full/Agda/Syntax/Parser/Tokens.hs6
-rw-r--r--src/full/Agda/Syntax/Position.hs275
-rw-r--r--src/full/Agda/Syntax/Scope/Base.hs29
-rw-r--r--src/full/Agda/Syntax/Scope/Monad.hs197
-rw-r--r--src/full/Agda/Syntax/Translation/AbstractToConcrete.hs142
-rw-r--r--src/full/Agda/Syntax/Translation/ConcreteToAbstract.hs454
-rw-r--r--src/full/Agda/Syntax/Translation/InternalToAbstract.hs961
-rw-r--r--src/full/Agda/Syntax/Translation/ReflectedToAbstract.hs44
-rw-r--r--src/full/Agda/Syntax/Treeless.hs49
-rw-r--r--src/full/Agda/Termination/CallGraph.hs58
-rw-r--r--src/full/Agda/Termination/CallMatrix.hs104
-rw-r--r--src/full/Agda/Termination/Inlining.hs83
-rw-r--r--src/full/Agda/Termination/Monad.hs45
-rw-r--r--src/full/Agda/Termination/Order.hs208
-rw-r--r--src/full/Agda/Termination/RecCheck.hs5
-rw-r--r--src/full/Agda/Termination/Semiring.hs67
-rw-r--r--src/full/Agda/Termination/SparseMatrix.hs312
-rw-r--r--src/full/Agda/Termination/TermCheck.hs255
-rw-r--r--src/full/Agda/Termination/Termination.hs198
-rw-r--r--src/full/Agda/Tests.hs75
-rw-r--r--src/full/Agda/TypeChecking/Abstract.hs11
-rw-r--r--src/full/Agda/TypeChecking/CheckInternal.hs17
-rw-r--r--src/full/Agda/TypeChecking/CompiledClause.hs26
-rw-r--r--src/full/Agda/TypeChecking/CompiledClause/Compile.hs127
-rw-r--r--src/full/Agda/TypeChecking/CompiledClause/Match.hs50
-rw-r--r--src/full/Agda/TypeChecking/Constraints.hs50
-rw-r--r--src/full/Agda/TypeChecking/Conversion.hs160
-rw-r--r--src/full/Agda/TypeChecking/Coverage.hs327
-rw-r--r--src/full/Agda/TypeChecking/Coverage/Match.hs302
-rw-r--r--src/full/Agda/TypeChecking/Coverage/SplitTree.hs22
-rw-r--r--src/full/Agda/TypeChecking/Datatypes.hs20
-rw-r--r--src/full/Agda/TypeChecking/DisplayForm.hs55
-rw-r--r--src/full/Agda/TypeChecking/DropArgs.hs19
-rw-r--r--src/full/Agda/TypeChecking/Empty.hs2
-rw-r--r--src/full/Agda/TypeChecking/Errors.hs306
-rw-r--r--src/full/Agda/TypeChecking/EtaContract.hs14
-rw-r--r--src/full/Agda/TypeChecking/Forcing.hs5
-rw-r--r--src/full/Agda/TypeChecking/Free.hs224
-rw-r--r--src/full/Agda/TypeChecking/Free/Lazy.hs57
-rw-r--r--src/full/Agda/TypeChecking/Free/Old.hs29
-rw-r--r--src/full/Agda/TypeChecking/Free/Tests.hs118
-rw-r--r--src/full/Agda/TypeChecking/Implicit.hs60
-rw-r--r--src/full/Agda/TypeChecking/Injectivity.hs36
-rw-r--r--src/full/Agda/TypeChecking/InstanceArguments.hs145
-rw-r--r--src/full/Agda/TypeChecking/Irrelevance.hs32
-rw-r--r--src/full/Agda/TypeChecking/Level.hs93
-rw-r--r--src/full/Agda/TypeChecking/LevelConstraints.hs61
-rw-r--r--src/full/Agda/TypeChecking/MetaVars.hs268
-rw-r--r--src/full/Agda/TypeChecking/MetaVars.hs-boot8
-rw-r--r--src/full/Agda/TypeChecking/MetaVars/Mention.hs3
-rw-r--r--src/full/Agda/TypeChecking/MetaVars/Occurs.hs52
-rw-r--r--src/full/Agda/TypeChecking/Monad.hs2
-rw-r--r--src/full/Agda/TypeChecking/Monad/Base.hs759
-rw-r--r--src/full/Agda/TypeChecking/Monad/Benchmark.hs2
-rw-r--r--src/full/Agda/TypeChecking/Monad/Builtin.hs52
-rw-r--r--src/full/Agda/TypeChecking/Monad/Caching.hs1
-rw-r--r--src/full/Agda/TypeChecking/Monad/Closure.hs12
-rw-r--r--src/full/Agda/TypeChecking/Monad/Constraints.hs32
-rw-r--r--src/full/Agda/TypeChecking/Monad/Context.hs160
-rw-r--r--src/full/Agda/TypeChecking/Monad/Env.hs7
-rw-r--r--src/full/Agda/TypeChecking/Monad/Exception.hs3
-rw-r--r--src/full/Agda/TypeChecking/Monad/Local.hs40
-rw-r--r--src/full/Agda/TypeChecking/Monad/MetaVars.hs122
-rw-r--r--src/full/Agda/TypeChecking/Monad/Mutual.hs67
-rw-r--r--src/full/Agda/TypeChecking/Monad/Open.hs1
-rw-r--r--src/full/Agda/TypeChecking/Monad/Options.hs69
-rw-r--r--src/full/Agda/TypeChecking/Monad/Sharing.hs1
-rw-r--r--src/full/Agda/TypeChecking/Monad/Signature.hs387
-rw-r--r--src/full/Agda/TypeChecking/Monad/Signature.hs-boot9
-rw-r--r--src/full/Agda/TypeChecking/Monad/SizedTypes.hs9
-rw-r--r--src/full/Agda/TypeChecking/Monad/State.hs47
-rw-r--r--src/full/Agda/TypeChecking/Monad/Trace.hs16
-rw-r--r--src/full/Agda/TypeChecking/Patterns/Abstract.hs8
-rw-r--r--src/full/Agda/TypeChecking/Patterns/Match.hs109
-rw-r--r--src/full/Agda/TypeChecking/Patterns/Match.hs-boot14
-rw-r--r--src/full/Agda/TypeChecking/Polarity.hs17
-rw-r--r--src/full/Agda/TypeChecking/Positivity.hs232
-rw-r--r--src/full/Agda/TypeChecking/Positivity/Occurrence.hs170
-rw-r--r--src/full/Agda/TypeChecking/Positivity/Tests.hs27
-rw-r--r--src/full/Agda/TypeChecking/Pretty.hs174
-rw-r--r--src/full/Agda/TypeChecking/Pretty.hs-boot1
-rw-r--r--src/full/Agda/TypeChecking/Primitive.hs143
-rw-r--r--src/full/Agda/TypeChecking/ProjectionLike.hs63
-rw-r--r--src/full/Agda/TypeChecking/Quote.hs79
-rw-r--r--src/full/Agda/TypeChecking/ReconstructParameters.hs8
-rw-r--r--src/full/Agda/TypeChecking/RecordPatterns.hs56
-rw-r--r--src/full/Agda/TypeChecking/Records.hs217
-rw-r--r--src/full/Agda/TypeChecking/Records.hs-boot4
-rw-r--r--src/full/Agda/TypeChecking/Reduce.hs318
-rw-r--r--src/full/Agda/TypeChecking/Reduce/Fast.hs534
-rw-r--r--src/full/Agda/TypeChecking/Reduce/Fast.hs-boot8
-rw-r--r--src/full/Agda/TypeChecking/Reduce/Monad.hs17
-rw-r--r--src/full/Agda/TypeChecking/Rewriting.hs252
-rw-r--r--src/full/Agda/TypeChecking/Rewriting.hs-boot2
-rw-r--r--src/full/Agda/TypeChecking/Rewriting/NonLinMatch.hs387
-rw-r--r--src/full/Agda/TypeChecking/Rules/Builtin.hs52
-rw-r--r--src/full/Agda/TypeChecking/Rules/Builtin/Coinduction.hs35
-rw-r--r--src/full/Agda/TypeChecking/Rules/Data.hs59
-rw-r--r--src/full/Agda/TypeChecking/Rules/Decl.hs254
-rw-r--r--src/full/Agda/TypeChecking/Rules/Decl.hs-boot6
-rw-r--r--src/full/Agda/TypeChecking/Rules/Def.hs336
-rw-r--r--src/full/Agda/TypeChecking/Rules/Def.hs-boot4
-rw-r--r--src/full/Agda/TypeChecking/Rules/Display.hs16
-rw-r--r--src/full/Agda/TypeChecking/Rules/LHS.hs389
-rw-r--r--src/full/Agda/TypeChecking/Rules/LHS/AsPatterns.hs117
-rw-r--r--src/full/Agda/TypeChecking/Rules/LHS/Implicit.hs15
-rw-r--r--src/full/Agda/TypeChecking/Rules/LHS/Instantiate.hs9
-rw-r--r--src/full/Agda/TypeChecking/Rules/LHS/Problem.hs88
-rw-r--r--src/full/Agda/TypeChecking/Rules/LHS/ProblemRest.hs34
-rw-r--r--src/full/Agda/TypeChecking/Rules/LHS/Split.hs142
-rw-r--r--src/full/Agda/TypeChecking/Rules/LHS/Unify.hs584
-rw-r--r--src/full/Agda/TypeChecking/Rules/Record.hs191
-rw-r--r--src/full/Agda/TypeChecking/Rules/Term.hs727
-rw-r--r--src/full/Agda/TypeChecking/Serialise.hs5
-rw-r--r--src/full/Agda/TypeChecking/Serialise/Base.hs1
-rw-r--r--src/full/Agda/TypeChecking/Serialise/Instances/Abstract.hs12
-rw-r--r--src/full/Agda/TypeChecking/Serialise/Instances/Common.hs60
-rw-r--r--src/full/Agda/TypeChecking/Serialise/Instances/Compilers.hs2
-rw-r--r--src/full/Agda/TypeChecking/Serialise/Instances/Highlighting.hs2
-rw-r--r--src/full/Agda/TypeChecking/Serialise/Instances/Internal.hs139
-rw-r--r--src/full/Agda/TypeChecking/SizedTypes.hs3
-rw-r--r--src/full/Agda/TypeChecking/SizedTypes/Solve.hs411
-rw-r--r--src/full/Agda/TypeChecking/SizedTypes/Syntax.hs23
-rw-r--r--src/full/Agda/TypeChecking/SizedTypes/Tests.hs145
-rw-r--r--src/full/Agda/TypeChecking/SizedTypes/Utils.hs1
-rw-r--r--src/full/Agda/TypeChecking/SizedTypes/WarshallSolver.hs53
-rw-r--r--src/full/Agda/TypeChecking/Substitute.hs643
-rw-r--r--src/full/Agda/TypeChecking/Substitute/Class.hs256
-rw-r--r--src/full/Agda/TypeChecking/Substitute/DeBruijn.hs54
-rw-r--r--src/full/Agda/TypeChecking/Substitute/Pattern.hs43
-rw-r--r--src/full/Agda/TypeChecking/SyntacticEquality.hs14
-rw-r--r--src/full/Agda/TypeChecking/Telescope.hs73
-rw-r--r--src/full/Agda/TypeChecking/Telescope.hs-boot2
-rw-r--r--src/full/Agda/TypeChecking/Test/Generators.hs558
-rw-r--r--src/full/Agda/TypeChecking/Tests.hs98
-rw-r--r--src/full/Agda/TypeChecking/Unquote.hs131
-rw-r--r--src/full/Agda/TypeChecking/With.hs270
-rw-r--r--src/full/Agda/Utils/AssocList.hs1
-rw-r--r--src/full/Agda/Utils/Bag.hs72
-rw-r--r--src/full/Agda/Utils/Benchmark.hs35
-rw-r--r--src/full/Agda/Utils/BiMap.hs32
-rw-r--r--src/full/Agda/Utils/Cluster.hs105
-rw-r--r--src/full/Agda/Utils/Either.hs23
-rw-r--r--src/full/Agda/Utils/Empty.hs1
-rw-r--r--src/full/Agda/Utils/Environment.hs38
-rw-r--r--src/full/Agda/Utils/Except.hs4
-rw-r--r--src/full/Agda/Utils/Favorites.hs68
-rw-r--r--src/full/Agda/Utils/FileName.hs57
-rw-r--r--src/full/Agda/Utils/Function.hs1
-rw-r--r--src/full/Agda/Utils/Functor.hs1
-rw-r--r--src/full/Agda/Utils/Graph/AdjacencyMap/Unidirectional.hs36
-rw-r--r--src/full/Agda/Utils/Graph/AdjacencyMap/Unidirectional/Tests.hs362
-rw-r--r--src/full/Agda/Utils/Hash.hs11
-rw-r--r--src/full/Agda/Utils/Haskell/Syntax.hs110
-rw-r--r--src/full/Agda/Utils/Lens.hs1
-rw-r--r--src/full/Agda/Utils/List.hs175
-rw-r--r--src/full/Agda/Utils/ListT.hs13
-rw-r--r--src/full/Agda/Utils/ListT/Tests.hs47
-rw-r--r--src/full/Agda/Utils/Maybe/Strict.hs22
-rw-r--r--src/full/Agda/Utils/Memo.hs38
-rw-r--r--src/full/Agda/Utils/Monad.hs16
-rw-r--r--src/full/Agda/Utils/Null.hs1
-rw-r--r--src/full/Agda/Utils/Parser/MemoisedCPS.hs273
-rw-r--r--src/full/Agda/Utils/Parser/ReadP.hs2
-rw-r--r--src/full/Agda/Utils/PartialOrd.hs173
-rw-r--r--src/full/Agda/Utils/Permutation.hs22
-rw-r--r--src/full/Agda/Utils/Permutation/Tests.hs117
-rw-r--r--src/full/Agda/Utils/Pretty.hs6
-rw-r--r--src/full/Agda/Utils/QuickCheck.hs16
-rw-r--r--src/full/Agda/Utils/Singleton.hs3
-rw-r--r--src/full/Agda/Utils/Suffix.hs1
-rw-r--r--src/full/Agda/Utils/TestHelpers.hs169
-rw-r--r--src/full/Agda/Utils/Trie.hs76
-rw-r--r--src/full/Agda/Utils/Tuple.hs4
-rw-r--r--src/full/Agda/Utils/Warshall.hs115
-rw-r--r--src/full/Agda/VersionCommit.hs25
-rw-r--r--stack-7.8.4.yaml27
-rw-r--r--stack-8.0.1.yaml5
321 files changed, 29083 insertions, 22611 deletions
diff --git a/Agda.cabal b/Agda.cabal
index 3adcfac..749224a 100644
--- a/Agda.cabal
+++ b/Agda.cabal
@@ -1,6 +1,6 @@
name: Agda
-version: 2.5.1.2
-cabal-version: >= 1.8
+version: 2.5.2
+cabal-version: >= 1.10
build-type: Custom
license: OtherLicense
license-file: LICENSE
@@ -36,18 +36,22 @@ tested-with: GHC == 7.6.3
GHC == 7.8.4
GHC == 7.10.3
GHC == 8.0.1
-extra-source-files: src/full/undefined.h
+
+extra-source-files: CHANGELOG.md
README.md
- CHANGELOG
+ src/full/undefined.h
+ stack-7.8.4.yaml
+ stack-8.0.1.yaml
+
data-dir: src/data
data-files: Agda.css
+ agda.sty
emacs-mode/*.el
-- EpicInclude/AgdaPrelude.e
-- EpicInclude/stdagda.c
-- EpicInclude/stdagda.h
- agda.sty
- postprocess-latex.pl
- lib/prim/Agda/Primitive.agda
+ JS/agda-rts.js
+ JS/biginteger.js
lib/prim/Agda/Builtin/Bool.agda
lib/prim/Agda/Builtin/Char.agda
lib/prim/Agda/Builtin/Coinduction.agda
@@ -66,10 +70,14 @@ data-files: Agda.css
lib/prim/Agda/Builtin/String.agda
lib/prim/Agda/Builtin/TrustMe.agda
lib/prim/Agda/Builtin/Unit.agda
+ lib/prim/Agda/Primitive.agda
+ MAlonzo/src/MAlonzo/*.hs
+ postprocess-latex.pl
uhc-agda-base/LICENSE
- uhc-agda-base/uhc-agda-base.cabal
uhc-agda-base/src/UHC/Agda/*.hs
- MAlonzo/src/MAlonzo/*.hs
+ uhc-agda-base/src/UHC/Agda/double.c
+ uhc-agda-base/src/UHC/Agda/double.h
+ uhc-agda-base/uhc-agda-base.cabal
source-repository head
type: git
@@ -77,8 +85,8 @@ source-repository head
source-repository this
type: git
- location: https://github.com/agda/agda/tree/v2.5.1.2
- tag: v2.5.1.2
+ location: https://github.com/agda/agda/tree/v2.5.2.
+ tag: v2.5.2
flag cpphs
default: True
@@ -91,12 +99,23 @@ flag uhc
description:
Enable the UHC backend. For details, consult the Agda User Manual.
+flag debug
+ default: False
+ manual: True
+ description:
+ Enable debugging features that may slow Agda down.
+
library
hs-source-dirs: src/full
include-dirs: src/full
if flag(cpphs)
- build-tools: cpphs >= 1.19
+ -- We don't write an upper bound for cpphs because the
+ -- `build-tools` field can not be modified in Hackage.
+
+ -- If your change the lower bound of cpphs also change it in the
+ -- `.travis.yml` file [Issue #2315].
+ build-tools: cpphs >= 1.20.2
ghc-options: -pgmP cpphs -optP --cpp
if flag(uhc)
@@ -109,59 +128,60 @@ library
-- definitions, see module Agda.Compiler.UHC.Bridge.
cpp-options: -DUHC_BACKEND
+ if flag(debug)
+ cpp-options: -DDEBUG
+
if os(windows)
build-depends: Win32 >= 2.2 && < 2.4
- build-depends:
- array >= 0.4.0.1 && < 0.6
- , base >= 4.6.0.1 && < 4.10
- , binary >= 0.7.2.1 && < 0.9
- , boxes >= 0.1.3 && < 0.2
- , bytestring >= 0.10.0.2 && < 0.11
- , containers >= 0.5.0.0 && < 0.6
- , data-hash >= 0.2.0.0 && < 0.3
- , deepseq >= 1.3.0.1 && < 1.5
- , directory >= 1.2.0.1 && < 1.3
- -- Edison versioning scheme: http://rwd.rdockins.name/edison/home/.
- -- EdisonAPI isn't used by Agda, but EdisonCore 1.3.1 doesn't
- -- declare what version of EdisonAPI it depends on.
- , EdisonAPI == 1.3
- , EdisonCore >= 1.3.1.1 && < 1.3.2
- , edit-distance >= 0.2.1.2 && < 0.3
- , equivalence >= 0.2.5 && < 0.4
- , filepath >= 1.3.0.1 && < 1.5
- , geniplate-mirror >= 0.6.0.6 && < 0.8
- -- hashable 1.2.0.10 makes library-test 10x slower. The issue was
- -- fixed in hashable 1.2.1.0.
- -- https://github.com/tibbe/hashable/issues/57.
- , hashable >= 1.2.1.0 && < 1.3
- -- There is a "serious bug"
- -- (https://hackage.haskell.org/package/hashtables-1.2.0.2/changelog)
- -- in hashtables 1.2.0.0/1.2.0.1. This bug seems to have made Agda
- -- much slower (infinitely slower?) in some cases.
- , hashtables >= 1.0.1.8 && < 1.2 || >= 1.2.0.2 && < 1.3
- , haskeline >= 0.7.1.3 && < 0.8
- , haskell-src-exts >= 1.16.0.1 && < 1.18
- , monadplus >= 1.4 && < 1.5
- -- mtl-2.1 contains a severe bug.
- --
- -- mtl >= 2.2 && < 2.2.1 doesn't export Control.Monad.Except.
- , mtl >= 2.1.1 && <= 2.1.3.1 || >= 2.2.1 && < 2.3
- , QuickCheck >= 2.8.2 && < 2.9
- , parallel >= 3.2.0.4 && < 3.3
- -- pretty 1.1.1.2 and 1.1.1.3 do not follow the package versioning
- -- policy.
- , pretty >= 1.1.1.0 && < 1.1.1.2 || >= 1.1.2 && < 1.2
- , process >= 1.1.0.2 && < 1.5
- , strict >= 0.3.2 && < 0.4
- , template-haskell >= 2.8.0.0 && < 2.12
- , text >= 0.11.3.1 && < 1.3
- , time >= 1.4.0.1 && < 1.7
- -- transformers 0.4.0.0 was deprecated.
- , transformers >= 0.3 && < 0.4 || >= 0.4.1.0 && < 0.6
- , transformers-compat >= 0.3.3.3 && < 0.6
- , unordered-containers >= 0.2.5.0 && < 0.3
- , xhtml >= 3000.2.1 && < 3000.3
+ build-depends: array >= 0.4.0.1 && < 0.6
+ , base >= 4.6.0.1 && < 4.10
+ , binary >= 0.7.2.1 && < 0.9
+ , boxes >= 0.1.3 && < 0.2
+ , bytestring >= 0.10.0.2 && < 0.11
+ , containers >= 0.5.0.0 && < 0.6
+ , data-hash >= 0.2.0.0 && < 0.3
+ , deepseq >= 1.3.0.1 && < 1.5
+ , directory >= 1.2.0.1 && < 1.4
+ , EdisonCore >= 1.3.1.1 && < 1.3.2
+ , edit-distance >= 0.2.1.2 && < 0.3
+ , equivalence >= 0.2.5 && < 0.4
+ , filepath >= 1.3.0.1 && < 1.5
+ , geniplate-mirror >= 0.6.0.6 && < 0.8
+ , gitrev >= 1.2 && < 2.0
+ -- hashable 1.2.0.10 makes library-test 10x
+ -- slower. The issue was fixed in hashable 1.2.1.0.
+ -- https://github.com/tibbe/hashable/issues/57.
+ , hashable >= 1.2.1.0 && < 1.3
+ -- There is a "serious bug"
+ -- (https://hackage.haskell.org/package/hashtables-1.2.0.2/changelog)
+ -- in hashtables 1.2.0.0/1.2.0.1. This bug seems to
+ -- have made Agda much slower (infinitely slower?) in
+ -- some cases.
+ , hashtables >= 1.0.1.8 && < 1.2 || >= 1.2.0.2 && < 1.3
+ , haskeline >= 0.7.1.3 && < 0.8
+ , ieee754 >= 0.7.8 && < 0.8
+ , monadplus >= 1.4 && < 1.5
+ -- mtl-2.1 contains a severe bug.
+ --
+ -- mtl >= 2.2 && < 2.2.1 doesn't export Control.Monad.Except.
+ , mtl >= 2.1.1 && <= 2.1.3.1 || >= 2.2.1 && < 2.3
+ , murmur-hash >= 0.1 && < 0.2
+ , parallel >= 3.2.0.4 && < 3.3
+ -- pretty 1.1.1.2 and 1.1.1.3 do not follow the
+ -- package versioning policy.
+ , pretty >= 1.1.1.0 && < 1.1.1.2 || >= 1.1.2 && < 1.2
+ , process >= 1.1.0.2 && < 1.5
+ , regex-tdfa >= 1.2.2 && < 1.3
+ , strict >= 0.3.2 && < 0.4
+ , template-haskell >= 2.8.0.0 && < 2.12
+ , text >= 0.11.3.1 && < 1.3
+ , time >= 1.4.0.1 && < 1.7
+ -- transformers 0.4.0.0 was deprecated.
+ , transformers >= 0.3 && < 0.4 || >= 0.4.1.0 && < 0.6
+ , transformers-compat >= 0.3.3.3 && < 0.6
+ , unordered-containers >= 0.2.5.0 && < 0.3
+ , xhtml >= 3000.2.1 && < 3000.3
if impl(ghc < 7.8)
build-depends: base-orphans >= 0.3.1 && < 0.5
@@ -175,6 +195,12 @@ library
else
build-depends: zlib >= 0.4.0.1 && < 0.7
+ if impl(ghc < 8.0)
+ -- provide/emulate `Control.Monad.Fail` and `Data.Semigroups` API
+ -- for pre-GHC8
+ build-depends: fail == 4.9.*
+ , semigroups == 0.18.*
+
-- Agda doesn't build with Alex 3.2.0.
build-tools: alex >= 3.1.0 && < 3.2.0 || >= 3.2.1 && < 3.3
, happy >= 1.19.4 && < 2
@@ -205,11 +231,9 @@ library
Agda.Compiler.Epic.Smashing
Agda.Compiler.Epic.Static
Agda.Compiler.HaskellTypes
- Agda.Compiler.JS.Case
Agda.Compiler.JS.Compiler
Agda.Compiler.JS.Syntax
Agda.Compiler.JS.Substitution
- Agda.Compiler.JS.Parser
Agda.Compiler.JS.Pretty
Agda.Compiler.MAlonzo.Compiler
Agda.Compiler.MAlonzo.Encode
@@ -217,10 +241,14 @@ library
Agda.Compiler.MAlonzo.Pretty
Agda.Compiler.MAlonzo.Primitives
Agda.Compiler.ToTreeless
+ Agda.Compiler.Treeless.AsPatterns
Agda.Compiler.Treeless.Builtin
Agda.Compiler.Treeless.Compare
+ Agda.Compiler.Treeless.DelayCoinduction
+ Agda.Compiler.Treeless.EliminateLiteralPatterns
Agda.Compiler.Treeless.Erase
Agda.Compiler.Treeless.GuardsToPrims
+ Agda.Compiler.Treeless.Identity
Agda.Compiler.Treeless.NormalizeNames
Agda.Compiler.Treeless.Pretty
Agda.Compiler.Treeless.Simplify
@@ -235,14 +263,12 @@ library
Agda.Compiler.UHC.Pragmas.Base
Agda.Compiler.UHC.Pragmas.Parse
Agda.Compiler.UHC.Primitives
- Agda.Compiler.UHC.Smashing
Agda.ImpossibleTest
Agda.Interaction.BasicOps
Agda.Interaction.SearchAbout
Agda.Interaction.CommandLine
Agda.Interaction.EmacsCommand
Agda.Interaction.EmacsTop
- Agda.Interaction.Exceptions
Agda.Interaction.FindFile
Agda.Interaction.Highlighting.Dot
Agda.Interaction.Highlighting.Emacs
@@ -273,16 +299,19 @@ library
Agda.Syntax.Concrete.Generic
Agda.Syntax.Concrete.Name
Agda.Syntax.Concrete.Operators.Parser
+ Agda.Syntax.Concrete.Operators.Parser.Monad
Agda.Syntax.Concrete.Operators
Agda.Syntax.Concrete.Pretty
Agda.Syntax.Concrete
Agda.Syntax.Fixity
+ Agda.Syntax.IdiomBrackets
Agda.Syntax.Info
Agda.Syntax.Internal
Agda.Syntax.Internal.Defs
Agda.Syntax.Internal.Generic
Agda.Syntax.Internal.Names
Agda.Syntax.Internal.Pattern
+ Agda.Syntax.Internal.SanityCheck
Agda.Syntax.Literal
Agda.Syntax.Notation
Agda.Syntax.Parser.Alex
@@ -290,6 +319,7 @@ library
Agda.Syntax.Parser.Layout
Agda.Syntax.Parser.LexActions
Agda.Syntax.Parser.Lexer
+ Agda.Syntax.Parser.Literate
Agda.Syntax.Parser.LookAhead
Agda.Syntax.Parser.Monad
Agda.Syntax.Parser.Parser
@@ -316,7 +346,6 @@ library
Agda.Termination.Semiring
Agda.Termination.TermCheck
Agda.Termination.Termination
- Agda.Tests
Agda.TheTypeChecker
Agda.TypeChecking.Abstract
Agda.TypeChecking.CheckInternal
@@ -338,7 +367,6 @@ library
Agda.TypeChecking.Free
Agda.TypeChecking.Free.Lazy
Agda.TypeChecking.Free.Old
- Agda.TypeChecking.Free.Tests
Agda.TypeChecking.Forcing
Agda.TypeChecking.Implicit
Agda.TypeChecking.Injectivity
@@ -359,6 +387,7 @@ library
Agda.TypeChecking.Monad.Env
Agda.TypeChecking.Monad.Exception
Agda.TypeChecking.Monad.Imports
+ Agda.TypeChecking.Monad.Local
Agda.TypeChecking.Monad.MetaVars
Agda.TypeChecking.Monad.Mutual
Agda.TypeChecking.Monad.Open
@@ -375,7 +404,6 @@ library
Agda.TypeChecking.Polarity
Agda.TypeChecking.Positivity
Agda.TypeChecking.Positivity.Occurrence
- Agda.TypeChecking.Positivity.Tests
Agda.TypeChecking.Pretty
Agda.TypeChecking.Primitive
Agda.TypeChecking.ProjectionLike
@@ -384,6 +412,7 @@ library
Agda.TypeChecking.RecordPatterns
Agda.TypeChecking.Records
Agda.TypeChecking.Reduce
+ Agda.TypeChecking.Reduce.Fast
Agda.TypeChecking.Reduce.Monad
Agda.TypeChecking.Rewriting
Agda.TypeChecking.Rewriting.NonLinMatch
@@ -394,6 +423,7 @@ library
Agda.TypeChecking.Rules.Def
Agda.TypeChecking.Rules.Display
Agda.TypeChecking.Rules.LHS
+ Agda.TypeChecking.Rules.LHS.AsPatterns
Agda.TypeChecking.Rules.LHS.Implicit
Agda.TypeChecking.Rules.LHS.Instantiate
Agda.TypeChecking.Rules.LHS.Problem
@@ -413,15 +443,13 @@ library
Agda.TypeChecking.SizedTypes
Agda.TypeChecking.SizedTypes.Solve
Agda.TypeChecking.SizedTypes.Syntax
- Agda.TypeChecking.SizedTypes.Tests
Agda.TypeChecking.SizedTypes.Utils
Agda.TypeChecking.SizedTypes.WarshallSolver
Agda.TypeChecking.Substitute
- Agda.TypeChecking.Substitute.Pattern
+ Agda.TypeChecking.Substitute.Class
+ Agda.TypeChecking.Substitute.DeBruijn
Agda.TypeChecking.SyntacticEquality
Agda.TypeChecking.Telescope
- Agda.TypeChecking.Test.Generators
- Agda.TypeChecking.Tests
Agda.TypeChecking.Unquote
Agda.TypeChecking.With
Agda.Utils.AssocList
@@ -440,9 +468,9 @@ library
Agda.Utils.Function
Agda.Utils.Geniplate
Agda.Utils.Graph.AdjacencyMap.Unidirectional
- Agda.Utils.Graph.AdjacencyMap.Unidirectional.Tests
Agda.Utils.Hash
Agda.Utils.HashMap
+ Agda.Utils.Haskell.Syntax
Agda.Utils.Impossible
Agda.Utils.IO.Binary
Agda.Utils.IO.Directory
@@ -452,7 +480,6 @@ library
Agda.Utils.Lens.Examples
Agda.Utils.List
Agda.Utils.ListT
- Agda.Utils.ListT.Tests
Agda.Utils.Map
Agda.Utils.Maybe
Agda.Utils.Maybe.Strict
@@ -463,16 +490,13 @@ library
Agda.Utils.Parser.ReadP
Agda.Utils.PartialOrd
Agda.Utils.Permutation
- Agda.Utils.Permutation.Tests
Agda.Utils.Pointer
Agda.Utils.Pretty
- Agda.Utils.QuickCheck
Agda.Utils.SemiRing
Agda.Utils.Singleton
Agda.Utils.Size
Agda.Utils.String
Agda.Utils.Suffix
- Agda.Utils.TestHelpers
Agda.Utils.Time
Agda.Utils.Trie
Agda.Utils.Tuple
@@ -480,12 +504,20 @@ library
Agda.Utils.VarSet
Agda.Utils.Warshall
Agda.Version
+ Agda.VersionCommit
other-modules: Paths_Agda
+ -- Initially, we disable all the warnings.
+ ghc-options: -w
+
+ -- This option must be the first one after disabling the warnings. See
+ -- Issue #2094.
+ if impl(ghc >= 8.0)
+ ghc-options: -Wunrecognised-warning-flags
+
if impl(ghc >= 7.6.3)
- ghc-options: -w
- -fwarn-deprecated-flags
+ ghc-options: -fwarn-deprecated-flags
-fwarn-dodgy-exports
-fwarn-dodgy-foreign-imports
-fwarn-dodgy-imports
@@ -496,7 +528,6 @@ library
-fwarn-missing-fields
-fwarn-missing-methods
-fwarn-missing-signatures
- -fwarn-orphans
-fwarn-tabs
-fwarn-overlapping-patterns
-fwarn-unrecognised-pragmas
@@ -512,6 +543,8 @@ library
if impl(ghc >= 7.10)
ghc-options: -fwarn-unticked-promoted-constructors
+ -- Enable after removing the support for GHC 7.8.
+ -- -fwarn-deriving-typeable
-- This option is deprected in GHC 7.10.1.
if impl(ghc >= 7.8) && impl(ghc < 7.10)
@@ -530,16 +563,40 @@ library
ghc-options: -fwarn-context-quantification
if impl(ghc >= 8.0)
- ghc-options: -Wnoncanonical-monad-instances
+ ghc-options: -Wmissing-pattern-synonym-signatures
+ -Wnoncanonical-monad-instances
+ -Wnoncanonical-monoid-instances
+ -Wsemigroup
+ -Wunused-foralls
+
+ default-language: Haskell2010
+ default-extensions: ConstraintKinds
+ , DataKinds
+ , DefaultSignatures
+ , DeriveFunctor
+ , DeriveFoldable
+ , DeriveTraversable
+ , ExistentialQuantification
+ , FlexibleContexts
+ , FlexibleInstances
+ , FunctionalDependencies
+ , LambdaCase
+ , MultiParamTypeClasses
+ , NamedFieldPuns
+ , RankNTypes
+ , RecordWildCards
+ , StandaloneDeriving
+ , TupleSections
+ , TypeSynonymInstances
executable agda
hs-source-dirs: src/main
main-is: Main.hs
- build-depends:
- Agda == 2.5.1.2
- -- Nothing is used from the following package, except for the
- -- prelude.
- , base >= 4.6.0.1 && < 6
+ build-depends: Agda == 2.5.2
+ -- Nothing is used from the following package,
+ -- except for the prelude.
+ , base >= 4.6.0.1 && < 6
+ default-language: Haskell2010
if impl(ghc >= 7)
-- If someone installs Agda with the setuid bit set, then the
-- presence of +RTS may be a security problem (see GHC bug #3910).
@@ -552,26 +609,8 @@ executable agda-mode
hs-source-dirs: src/agda-mode
main-is: Main.hs
other-modules: Paths_Agda
- build-depends:
- base >= 4.6.0.1 && < 4.10
- , directory >= 1.2.0.1 && < 1.3
- , filepath >= 1.3.0.1 && < 1.5
- , process >= 1.1.0.2 && < 1.5
-
-executable agda-ghc-names
- hs-source-dirs: src/agda-ghc-names
- main-is: agda-ghc-names.hs
- other-modules: ExtractNames
- , Find
- , FixProf
- , ResolveHsNames
- build-depends:
- base >= 4.6.0.1 && < 4.10
- , binary >= 0.7.2.1 && < 0.9
- , containers >= 0.5.0.0 && < 0.6
- , filemanip >= 0.3.6.3 && < 0.4
- , haskell-src-exts >= 1.16.0.1 && < 1.18
- , mtl >= 2.1.1 && <= 2.1.3.1 || >= 2.2.1 && < 2.3
- , filepath >= 1.3.0.1 && < 1.5
- ghc-options: -rtsopts
-
+ build-depends: base >= 4.6.0.1 && < 4.10
+ , directory >= 1.2.0.1 && < 1.4
+ , filepath >= 1.3.0.1 && < 1.5
+ , process >= 1.1.0.2 && < 1.5
+ default-language: Haskell2010
diff --git a/CHANGELOG b/CHANGELOG
deleted file mode 100644
index 3a42d11..0000000
--- a/CHANGELOG
+++ /dev/null
@@ -1,6677 +0,0 @@
-------------------------------------------------------------------------
--- Release notes for Agda version 2.5.1.2
-------------------------------------------------------------------------
-
-* Fixed broken type signatures that were incorrectly accepted due to
- GHC #12784 (https://ghc.haskell.org/trac/ghc/ticket/12784).
-
-------------------------------------------------------------------------
--- Release notes for Agda version 2.5.1.1
-------------------------------------------------------------------------
-
-Important changes since 2.5.1:
-
-Installation and infrastructure
-===============================
-
-* Added support for GHC 8.0.1.
-
-Bug fixes
-=========
-
-* Fixed a serious performance problem with instance search
-
- Issues #1952 and #1998. Also related: #1955 and #2025
-
-* Interactively splitting variable with C-c C-c no longer introduces
- new trailing patterns. This fixes issue #1950.
-
- data Ty : Set where
- _⇒_ : Ty → Ty → Ty
-
- ⟦_⟧ : Ty → Set
- ⟦ A ⇒ B ⟧ = ⟦ A ⟧ → ⟦ B ⟧
-
- data Term : Ty → Set where
- K : (A B : Ty) → Term (A ⇒ (B ⇒ A))
-
- test : (A : Ty) (a : Term A) → ⟦ A ⟧
- test A a = {!a!}
-
- Before change, case splitting on `a` would give
-
- test .(A ⇒ (B ⇒ A)) (K A B) x x₁ = ?
-
- Now, it yields
-
- test .(A ⇒ (B ⇒ A)) (K A B) = ?
-
-* Other issues fixed ( see https://github.com/agda/agda/issues ):
- - #1322 (Missing error for attempted higher order instance)
- - #1951 (mixfix binders not working in 'syntax')
- - #1967 (too eager insteance search error)
- - #1974 (lost constraint dependencies)
- - #1982 (internal error in unifier)
- - #2034 (function type instance goals)
-
-Compiler backends
-=================
-
-* UHC compiler backend
-
- Added support for UHC 1.1.9.4.
-
-------------------------------------------------------------------------
--- Release notes for Agda version 2.5.1
-------------------------------------------------------------------------
-
-Important changes since 2.4.2.5:
-
-Documentation
-=============
-
-* There is now an official Agda User Manual:
- http://agda.readthedocs.org/en/stable/
-
-Installation and infrastructure
-===============================
-
-* Builtins and primitives are now defined in a new set of modules available to
- all users, independent of any particular library. The modules are
-
- Agda.Builtin.Bool
- Agda.Builtin.Char
- Agda.Builtin.Coinduction
- Agda.Builtin.Equality
- Agda.Builtin.Float
- Agda.Builtin.FromNat
- Agda.Builtin.FromNeg
- Agda.Builtin.FromString
- Agda.Builtin.IO
- Agda.Builtin.Int
- Agda.Builtin.List
- Agda.Builtin.Nat
- Agda.Builtin.Reflection
- Agda.Builtin.Size
- Agda.Builtin.Strict
- Agda.Builtin.String
- Agda.Builtin.TrustMe
- Agda.Builtin.Unit
-
- The standard library reexports the primitives from the new modules.
-
- The Agda.Builtin modules are installed in the same way as Agda.Primitive,
- but unlike Agda.Primitive they are not loaded automatically.
-
-Pragmas and options
-===================
-
-* Library management
-
- There is a new 'library' concept for managing include paths. A library
- consists of
- - a name,
- - a set of libraries it depends on, and
- - a set of include paths.
-
- A library is defined in a .agda-lib file using the following format:
-
- name: LIBRARY-NAME -- Comment
- depend: LIB1 LIB2
- LIB3
- LIB4
- include: PATH1
- PATH2
- PATH3
-
- Dependencies are library names, not paths to .agda-lib files, and
- include paths are relative to the location of the library-file.
-
- To be useable, a library file has to be listed (with its full path) in
- AGDA_DIR/libraries (or AGDA_DIR/libraries-VERSION, for a given Agda
- version). AGDA_DIR defaults to ~/.agda on unix-like systems
- and C:/Users/USERNAME/AppData/Roaming/agda or similar on Windows, and can be
- overridden by setting the AGDA_DIR environment variable.
-
- Environment variables in the paths (of the form $VAR or ${VAR}) are
- expanded. The location of the libraries file used can be overridden using the
- --library-file=FILE flag, although this is not expected to be very useful.
-
- You can find out the precise location of the 'libraries' file by
- calling 'agda -l fjdsk Dummy.agda' and looking at the error message (assuming
- you don't have a library called fjdsk installed).
-
- There are three ways a library gets used:
-
- - You supply the --library=LIB (or -l LIB) option to Agda. This is
- equivalent to adding a -iPATH for each of the include paths of LIB
- and its (transitive) dependencies.
-
- - No explicit --library flag is given, and the current project root
- (of the Agda file that is being loaded) or one of its parent directories
- contains a .agda-lib file defining a library LIB. This library is used as
- if a --librarary=LIB option had been given, except that it is not
- necessary for the library to be listed in the AGDA_DIR/libraries file.
-
- - No explicit --library flag, and no .agda-lib file in the project
- root. In this case the file AGDA_DIR/defaults is read and all
- libraries listed are added to the path. The defaults file should
- contain a list of library names, each on a separate line. In this
- case the current directory is also added to the path.
-
- To disable default libraries, you can give the flag
- --no-default-libraries.
-
- Library names can end with a version number (for instance,
- mylib-1.2.3). When resolving a library name (given in a --library
- flag, or listed as a default library or library dependency) the
- following rules are followed:
-
- - If you don't give a version number, any version will do.
- - If you give a version number an exact match is required.
- - When there are multiple matches an exact match is preferred, and
- otherwise the latest matching version is chosen.
-
- For example, suppose you have the following libraries installed:
- mylib, mylib-1.0, otherlib-2.1, and otherlib-2.3. In this case, aside
- from the exact matches you can also say --library=otherlib to get
- otherlib-2.3.
-
-* New Pragma COMPILED_DECLARE_DATA for binding recursively defined
- Haskell data types to recursively defined Agda data types.
-
- If you have a Haskell type like
-
- {-# LANGUAGE GADTs #-}
-
- module Issue223 where
-
- data A where
- BA :: B -> A
-
- data B where
- AB :: A -> B
- BB :: B
-
- You can now bind it to corresponding mutual Agda inductive data
- types as follows:
-
- {-# IMPORT Issue223 #-}
-
- data A : Set
- {-# COMPILED_DECLARE_DATA A Issue223.A #-}
- data B : Set
- {-# COMPILED_DECLARE_DATA B Issue223.B #-}
-
- data A where
- BA : B → A
-
- {-# COMPILED_DATA A Issue223.A Issue223.BA #-}
- data B where
- AB : A → B
- BB : B
-
- {-# COMPILED_DATA B Issue223.B Issue223.AB Issue223.BB #-}
-
- This fixes issue 223.
-
-* New pragma HASKELL for adding inline Haskell code (GHC backend only)
-
- Arbitrary Haskell code can be added to a module using the HASKELL pragma.
- For instance,
-
- {-# HASKELL
- echo :: IO ()
- echo = getLine >>= putStrLn
- #-}
-
- postulate echo : IO ⊤
- {-# COMPILED echo echo #-}
-
-* New option --exact-split.
-
- The --exact-split flag causes Agda to raise an error whenever a clause in a
- definition by pattern matching cannot be made to hold definitionally (i.e. as
- a reduction rule). Specific clauses can be excluded from this check by means
- of the {-# CATCHALL #-} pragma.
-
- For instance, the following definition will be rejected as the second clause
- cannot be made to hold definitionally:
-
- min : Nat → Nat → Nat
- min zero y = zero
- min x zero = zero
- min (suc x) (suc y) = suc (min x y)
-
- Catchall clauses have to be marked as such, for instance:
-
- eq : Nat → Nat → Bool
- eq zero zero = true
- eq (suc m) (suc n) = eq m n
- {-# CATCHALL #-}
- eq _ _ = false
-
-* New option: --no-exact-split.
-
- This option can be used to override a global --exact-split in a
- file, by adding a pragma {-# OPTIONS --no-exact-split #-}.
-
-* New options: --sharing and --no-sharing.
-
- These options are used to enable/disable sharing and call-by-need evaluation.
- The default is --no-sharing.
-
- Note that they cannot appear in an OPTIONS pragma, but have to be given as
- command line arguments or added to the Agda Program Args from Emacs with M-x
- customize-group agda2.
-
-* New pragma DISPLAY.
-
- {-# DISPLAY f e1 .. en = e #-}
-
- This causes f e1 .. en to be printed in the same way as e, where ei can bind
- variables used in e. The expressions ei and e are scope checked, but not
- type checked.
-
- For example this can be used to print overloaded (instance) functions with
- the overloaded name:
-
- instance
- NumNat : Num Nat
- NumNat = record { ..; _+_ = natPlus }
-
- {-# DISPLAY natPlus a b = a + b #-}
-
- Limitations
-
- Left-hand sides are restricted to variables, constructors, defined
- functions or types, and literals. In particular, lambdas are not allowed in
- left-hand sides.
-
- Since DISPLAY pragmas are not type checked implicit argument insertion may
- not work properly if the type of f computes to an implicit function space
- after pattern matching.
-
-* Removed pragma {-# ETA R #-}
-
- The pragma {-# ETA R #-} is replaced by the eta-equality directive
- inside record declarations.
-
-* New option --no-eta-equality.
-
- The --no-eta-equality flag disables eta rules for declared record types.
- It has the same effect as no-eta-equality inside each declaration of
- a record type R.
-
- If used with the OPTIONS pragma it will not affect records defined
- in other modules.
-
-* The semantics of {-# REWRITE r #-} pragmas in parametrized modules has
- changed (see Issue 1652).
-
- Rewrite rules are no longer lifted to the top context. Instead, they now only
- apply to terms in (extensions of) the module context. If you want the old
- behaviour, you should put the {-# REWRITE r #-} pragma outside of the module
- (i.e. unindent it).
-
-* New pragma {-# INLINE f #-} causes f to be inlined during compilation.
-
-* The STATIC pragma is now taken into account during compilation.
-
- Calls to a function marked STATIC are normalised before compilation. The
- typical use case for this is to mark the interpreter of an embedded language
- as STATIC.
-
-* Option --type-in-type no longer implies --no-universe-polymorphism,
- thus, it can be used with explicit universe levels. [Issue 1764]
- It simply turns off error reporting for any level mismatch now.
- Examples:
-
- {-# OPTIONS --type-in-type #-}
-
- Type : Set
- Type = Set
-
- data D {α} (A : Set α) : Set where
- d : A → D A
-
- data E α β : Set β where
- e : Set α → E α β
-
-* New NO_POSITIVITY_CHECK pragma to switch off the positivity checker
- for data/record definitions and mutual blocks.
-
- The pragma must precede a data/record definition or a mutual block.
-
- The pragma cannot be used in --safe mode.
-
- Examples (see Issue1614*.agda and Issue1760*.agda in test/Succeed/):
-
- 1. Skipping a single data definition.
-
- {-# NO_POSITIVITY_CHECK #-}
- data D : Set where
- lam : (D → D) → D
-
- 2. Skipping a single record definition.
-
- {-# NO_POSITIVITY_CHECK #-}
- record U : Set where
- field ap : U → U
-
- 3. Skipping an old-style mutual block: Somewhere within a `mutual`
- block before a data/record definition.
-
- mutual
- data D : Set where
- lam : (D → D) → D
-
- {-# NO_POSITIVITY_CHECK #-}
- record U : Set where
- field ap : U → U
-
- 4. Skipping an old-style mutual block: Before the `mutual` keyword.
-
- {-# NO_POSITIVITY_CHECK #-}
- mutual
- data D : Set where
- lam : (D → D) → D
-
- record U : Set where
- field ap : U → U
-
- 5. Skipping a new-style mutual block: Anywhere before the
- declaration or the definition of data/record in the block.
-
- record U : Set
- data D : Set
-
- record U where
- field ap : U → U
-
- {-# NO_POSITIVITY_CHECK #-}
- data D where
- lam : (D → D) → D
-
-* Removed --no-coverage-check option. [Issue 1918]
-
-Language
-========
-
-Operator syntax
----------------
-
-* The default fixity for syntax declarations has changed from -666 to 20.
-
-* Sections.
-
- Operators can be sectioned by replacing arguments with underscores.
- There must not be any whitespace between these underscores and the
- adjacent nameparts. Examples:
-
- pred : ℕ → ℕ
- pred = _∸ 1
-
- T : Bool → Set
- T = if_then ⊤ else ⊥
-
- if : {A : Set} (b : Bool) → A → A → A
- if b = if b then_else_
-
- Sections are translated into lambda expressions. Examples:
-
- _∸ 1 ↦ λ section → section ∸ 1
-
- if_then ⊤ else ⊥ ↦ λ section → if section then ⊤ else ⊥
-
- if b then_else_ ↦ λ section section₁ →
- if b then section else section₁
-
- Operator sections have the same fixity as the underlying operator
- (except in cases like "if b then_else_", in which the section is
- "closed", but the operator is not).
-
- Operator sections are not supported in patterns (with the exception
- of dot patterns), and notations coming from syntax declarations
- cannot be sectioned.
-
-* A long-standing operator fixity bug has been fixed. As a consequence
- some programs that used to parse no longer do.
-
- Previously each precedence level was (incorrectly) split up into
- five separate ones, ordered as follows, with the earlier ones
- binding less tightly than the later ones:
-
- - Non-associative operators.
-
- - Left associative operators.
-
- - Right associative operators.
-
- - Prefix operators.
-
- - Postfix operators.
-
- Now this problem has been addressed. It is no longer possible to mix
- operators of a given precedence level but different associativity.
- However, prefix and right associative operators are seen as having
- the same associativity, and similarly for postfix and left
- associative operators.
-
- Examples
- --------
-
- The following code is no longer accepted:
-
- infixl 6 _+_
- infix 6 _∸_
-
- rejected : ℕ
- rejected = 1 + 0 ∸ 1
-
- However, the following previously rejected code is accepted:
-
- infixr 4 _,_
- infix 4 ,_
-
- ,_ : {A : Set} {B : A → Set} {x : A} → B x → Σ A B
- , y = _ , y
-
- accepted : Σ ℕ λ i → Σ ℕ λ j → Σ (i ≡ j) λ _ → Σ ℕ λ k → j ≡ k
- accepted = 5 , , refl , , refl
-
-* The classification of notations with binders into the categories
- infix, prefix, postfix or closed has changed. [Issue 1450]
-
- The difference is that, when classifying the notation, only
- /regular/ holes are taken into account, not /binding/ ones.
-
- Example: The notation
-
- syntax m >>= (λ x → f) = x <- m , f
-
- was previously treated as infix, but is now treated as prefix.
-
-* Notation can now include wildcard binders.
-
- Example: syntax Σ A (λ _ → B) = A × B
-
-* If an overloaded operator is in scope with several distinct
- precedence levels, then several instances of this operator will be
- included in the operator grammar, possibly leading to ambiguity.
- Previously the operator was given the default fixity [Issue 1436].
-
- There is an exception to this rule: If there are multiple precedences,
- but at most one is explicitly declared, then only one instance will be
- included in the grammar. If there are no explicitly declared
- precedences, then this instance will get the default precedence, and
- otherwise it will get the declared precedence.
-
- If multiple occurrences of an operator are "merged" in the grammar,
- and they have distinct associativities, then they are treated as
- being non-associative.
-
- The three paragraphs above also apply to identical notations (coming
- from syntax declarations) for a given overloaded name.
-
- Examples:
-
- module A where
-
- infixr 5 _∷_
- infixr 5 _∙_
- infixl 3 _+_
- infix 1 bind
-
- syntax bind c (λ x → d) = x ← c , d
-
- module B where
-
- infix 5 _∷_
- infixr 4 _∙_
- -- No fixity declaration for _+_.
- infixl 2 bind
-
- syntax bind c d = c ∙ d
-
- module C where
-
- infixr 2 bind
-
- syntax bind c d = c ∙ d
-
- open A
- open B
- open C
-
- -- _∷_ is infix 5.
- -- _∙_ has two fixities: infixr 4 and infixr 5.
- -- _+_ is infixl 3.
- -- A.bind's notation is infix 1.
- -- B.bind and C.bind's notations are infix 2.
-
- -- There is one instance of "_ ∷ _" in the grammar, and one
- -- instance of "_ + _".
-
- -- There are three instances of "_ ∙ _" in the grammar, one
- -- corresponding to A._∙_, one corresponding to B._∙_, and one
- -- corresponding to both B.bind and C.bind.
-
-Reflection
-----------
-
-* The reflection framework has received a massive overhaul.
-
- A new type of reflected type checking computations supplants most of the old
- reflection primitives. The quoteGoal, quoteContext and tactic primitives are
- deprecated and will be removed in the future, and the unquoteDecl and unquote
- primitives have changed behaviour. Furthermore the following primitive
- functions have been replaced by builtin type checking computations:
-
- - primQNameType --> AGDATCMGETTYPE
- - primQNameDefinition --> AGDATCMGETDEFINITION
- - primDataConstructors --> subsumed by AGDATCMGETDEFINITION
- - primDataNumberOfParameters --> subsumed by AGDATCMGETDEFINITION
-
- See below for details.
-
-* Types are no longer packaged with a sort.
-
- The AGDATYPE and AGDATYPEEL built-ins have been removed. Reflected types are
- now simply terms.
-
-* Reflected definitions have more information.
-
- The type for reflected definitions has changed to
-
- data Definition : Set where
- fun-def : List Clause → Definition
- data-type : Nat → List Name → Definition -- parameters and constructors
- record-type : Name → Definition -- name of the data/record type
- data-con : Name → Definition -- name of the constructor
- axiom : Definition
- prim-fun : Definition
-
- Correspondingly the built-ins for function, data and record definitions
- (AGDAFUNDEF, AGDAFUNDEFCON, AGDADATADEF, AGDARECORDDEF) have been removed.
-
-* Reflected type checking computations.
-
- There is a primitive TC monad representing type checking computations. The
- unquote, unquoteDecl, and the new unquoteDef all expect computations in this
- monad (see below). The interface to the monad is the following
-
- -- Error messages can contain embedded names and terms.
- data ErrorPart : Set where
- strErr : String → ErrorPart
- termErr : Term → ErrorPart
- nameErr : Name → ErrorPart
-
- {-# BUILTIN AGDAERRORPART ErrorPart #-}
- {-# BUILTIN AGDAERRORPARTSTRING strErr #-}
- {-# BUILTIN AGDAERRORPARTTERM termErr #-}
- {-# BUILTIN AGDAERRORPARTNAME nameErr #-}
-
- postulate
- TC : ∀ {a} → Set a → Set a
- returnTC : ∀ {a} {A : Set a} → A → TC A
- bindTC : ∀ {a b} {A : Set a} {B : Set b} → TC A → (A → TC B) → TC B
-
- -- Unify two terms, potentially solving metavariables in the process.
- unify : Term → Term → TC ⊤
-
- -- Throw a type error. Can be caught by catchTC.
- typeError : ∀ {a} {A : Set a} → List ErrorPart → TC A
-
- -- Block a type checking computation on a metavariable. This will abort
- -- the computation and restart it (from the beginning) when the
- -- metavariable is solved.
- blockOnMeta : ∀ {a} {A : Set a} → Meta → TC A
-
- -- Backtrack and try the second argument if the first argument throws a
- -- type error.
- catchTC : ∀ {a} {A : Set a} → TC A → TC A → TC A
-
- -- Infer the type of a given term
- inferType : Term → TC Type
-
- -- Check a term against a given type. This may resolve implicit arguments
- -- in the term, so a new refined term is returned. Can be used to create
- -- new metavariables: newMeta t = checkType unknown t
- checkType : Term → Type → TC Term
-
- -- Compute the normal form of a term.
- normalise : Term → TC Term
-
- -- Get the current context.
- getContext : TC (List (Arg Type))
-
- -- Extend the current context with a variable of the given type.
- extendContext : ∀ {a} {A : Set a} → Arg Type → TC A → TC A
-
- -- Set the current context.
- inContext : ∀ {a} {A : Set a} → List (Arg Type) → TC A → TC A
-
- -- Quote a value, returning the corresponding Term.
- quoteTC : ∀ {a} {A : Set a} → A → TC Term
-
- -- Unquote a Term, returning the corresponding value.
- unquoteTC : ∀ {a} {A : Set a} → Term → TC A
-
- -- Create a fresh name.
- freshName : String → TC QName
-
- -- Declare a new function of the given type. The function must be defined
- -- later using 'defineFun'. Takes an Arg Name to allow declaring instances
- -- and irrelevant functions. The Visibility of the Arg must not be hidden.
- declareDef : Arg QName → Type → TC ⊤
-
- -- Define a declared function. The function may have been declared using
- -- 'declareDef' or with an explicit type signature in the program.
- defineFun : QName → List Clause → TC ⊤
-
- -- Get the type of a defined name. Replaces 'primQNameType'.
- getType : QName → TC Type
-
- -- Get the definition of a defined name. Replaces 'primQNameDefinition'.
- getDefinition : QName → TC Definition
-
- {-# BUILTIN AGDATCM TC #-}
- {-# BUILTIN AGDATCMRETURN returnTC #-}
- {-# BUILTIN AGDATCMBIND bindTC #-}
- {-# BUILTIN AGDATCMUNIFY unify #-}
- {-# BUILTIN AGDATCMNEWMETA newMeta #-}
- {-# BUILTIN AGDATCMTYPEERROR typeError #-}
- {-# BUILTIN AGDATCMBLOCKONMETA blockOnMeta #-}
- {-# BUILTIN AGDATCMCATCHERROR catchTC #-}
- {-# BUILTIN AGDATCMINFERTYPE inferType #-}
- {-# BUILTIN AGDATCMCHECKTYPE checkType #-}
- {-# BUILTIN AGDATCMNORMALISE normalise #-}
- {-# BUILTIN AGDATCMGETCONTEXT getContext #-}
- {-# BUILTIN AGDATCMEXTENDCONTEXT extendContext #-}
- {-# BUILTIN AGDATCMINCONTEXT inContext #-}
- {-# BUILTIN AGDATCMQUOTETERM quoteTC #-}
- {-# BUILTIN AGDATCMUNQUOTETERM unquoteTC #-}
- {-# BUILTIN AGDATCMFRESHNAME freshName #-}
- {-# BUILTIN AGDATCMDECLAREDEF declareDef #-}
- {-# BUILTIN AGDATCMDEFINEFUN defineFun #-}
- {-# BUILTIN AGDATCMGETTYPE getType #-}
- {-# BUILTIN AGDATCMGETDEFINITION getDefinition #-}
-
-* Builtin type for metavariables
-
- There is a new builtin type for metavariables used by the new reflection
- framework. It is declared as follows and comes with primitive equality,
- ordering and show.
-
- postulate Meta : Set
- {-# BUILTIN AGDAMETA Meta #-}
- primitive primMetaEquality : Meta → Meta → Bool
- primitive primMetaLess : Meta → Meta → Bool
- primitive primShowMeta : Meta → String
-
- There are corresponding new constructors in the Term and Literal data types:
-
- data Term : Set where
- ...
- meta : Meta → List (Arg Term) → Term
-
- {-# BUILTIN AGDATERMMETA meta #-}
-
- data Literal : Set where
- ...
- meta : Meta → Literal
-
- {-# BUILTIN AGDALITMETA meta #-}
-
-* Builtin unit type
-
- The type checker needs to know about the unit type, which you can allow by
-
- record ⊤ : Set where
- {-# BUILTIN UNIT ⊤ #-}
-
-* Changed behaviour of unquote
-
- The unquote primitive now expects a type checking computation instead of a
- pure term. In particular 'unquote e' requires
-
- e : Term → TC ⊤
-
- where the argument is the representation of the hole in which the result
- should go. The old unquote behaviour (where unquote expected a Term argument)
- can be recovered by
-
- OLD: unquote v
- NEW: unquote λ hole → unify hole v
-
-* Changed behaviour of unquoteDecl
-
- The unquoteDecl primitive now expects a type checking computation instead of
- a pure function definition. It is possible to define multiple (mutually
- recursive) functions at the same time. More specifically
-
- unquoteDecl x₁ .. xₙ = m
-
- requires m : TC ⊤ and that x₁ .. xₙ are defined (using declareDef and
- defineFun) after executing m. As before x₁ .. xₙ : QName in m, but have their
- declared types outside the unquoteDecl.
-
-* New primitive unquoteDef.
-
- There is a new declaration
-
- unquoteDef x₁ .. xₙ = m
-
- This works exactly as unquoteDecl (see above) with the exception that x₁ ..
- xₙ are required to already be declared.
-
- The main advantage of unquoteDef over unquoteDecl is that unquoteDef is
- allowed in mutual blocks, allowing mutually recursion between generated
- definitions and hand-written definitions.
-
-* The reflection interface now exposes the name hint (as a string)
- for variables. As before, the actual binding structure is with
- de Bruijn indices. The String value is just a hint used as a prefix
- to help display the variable. The type Abs is a new bultin type used
- for the constructors `Term.lam`, `Term.pi`, `Pattern.var`
- (bultins `AGDATERMLAM`, `AGDATERMPI` and `AGDAPATVAR`).
-
- data Abs (A : Set) : Set where
- abs : (s : String) (x : A) → Abs A
- {-# BUILTIN ABS Abs #-}
- {-# BUILTIN ABSABS abs #-}
-
- Updated constructor types:
-
- Term.lam : Hiding → Abs Term → Term
- Term.pi : Arg Type → Abs Type → Term
- Pattern.var : String → Pattern
-
-* Reflection-based macros
-
- Macros are functions of type t1 → t2 → .. → Term → TC ⊤ that are defined in a
- 'macro' block. Macro application is guided by the type of the macro, where
- Term arguments desugar into the 'quoteTerm' syntax and Name arguments into
- the 'quote' syntax. Arguments of any other type are preserved as-is. The last
- Term argument is the hole term given to 'unquote' computation (see above).
-
- For example, the macro application 'f u v w' where the macro
- f has the type 'Term → Name → Bool → Term → TC ⊤' desugars into
- 'unquote (f (quoteTerm u) (quote v) w)'
-
- Limitations:
-
- - Macros cannot be recursive. This can be worked around by defining the
- recursive function outside the macro block and have the macro call the
- recursive function.
-
- Silly example:
-
- macro
- plus-to-times : Term → Term → TC ⊤
- plus-to-times (def (quote _+_) (a ∷ b ∷ [])) hole = unify hole (def (quote _*_) (a ∷ b ∷ []))
- plus-to-times v hole = unify hole v
-
- thm : (a b : Nat) → plus-to-times (a + b) ≡ a * b
- thm a b = refl
-
- Macros are most useful when writing tactics, since they let you hide the
- reflection machinery. For instance, suppose you have a solver
-
- magic : Type → Term
-
- that takes a reflected goal and outputs a proof (when successful). You can
- then define the following macro
-
- macro
- by-magic : Term → TC ⊤
- by-magic hole =
- bindTC (inferType hole) λ goal →
- unify hole (magic goal)
-
- This lets you apply the magic tactic without any syntactic noise at all:
-
- thm : ¬ P ≡ NP
- thm = by-magic
-
-Literals and built-ins
-----------------------
-
-* Overloaded number literals.
-
- You can now overload natural number literals using the new builtin FROMNAT:
-
- {-# BUILTIN FROMNAT fromNat #-}
-
- The target of the builtin should be a defined name. Typically you would do
- something like
-
- record Number (A : Set) : Set where
- field fromNat : Nat → A
-
- open Number {{...}} public
-
- {-# BUILTIN FROMNAT fromNat #-}
-
- This will cause number literals 'n' to be desugared to 'fromNat n' before
- type checking.
-
-* Negative number literals.
-
- Number literals can now be negative. For floating point literals it works as
- expected. For integer literals there is a new builtin FROMNEG that enables
- negative integer literals:
-
- {-# BUILTIN FROMNEG fromNeg #-}
-
- This causes negative literals '-n' to be desugared to 'fromNeg n'.
-
-* Overloaded string literals.
-
- String literals can be overladed using the FROMSTRING builtin:
-
- {-# BUILTIN FROMSTRING fromString #-}
-
- The will cause string literals 's' to be desugared to 'fromString s' before
- type checking.
-
-* Change to builtin integers.
-
- The INTEGER builtin now needs to be bound to a datatype with two constructors
- that should be bound to the new builtins INTEGERPOS and INTEGERNEGSUC as follows:
-
- data Int : Set where
- pos : Nat -> Int
- negsuc : Nat -> Int
- {-# BUILTIN INTEGER Int #-}
- {-# BUILTIN INTEGERPOS pos #-}
- {-# BUILTIN INTEGERNEGSUC negsuc #-}
-
- where 'negsuc n' represents the integer '-n - 1'. For instance, '-5' is
- represented as 'negsuc 4'. All primitive functions on integers except
- primShowInteger have been removed, since these can be defined without too
- much trouble on the above representation using the corresponding functions on
- natural numbers.
-
- The primitives that have been removed are
-
- primIntegerPlus
- primIntegerMinus
- primIntegerTimes
- primIntegerDiv
- primIntegerMod
- primIntegerEquality
- primIntegerLess
- primIntegerAbs
- primNatToInteger
-
-* New primitives for strict evaluation
-
- primitive
- primForce : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) → (∀ x → B x) → B x
- primForceLemma : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) (f : ∀ x → B x) → primForce x f ≡ f x
-
- 'primForce x f' evaluates to 'f x' if x is in weak head normal form, and
- 'primForceLemma x f' evaluates to 'refl' in the same situation. The following
- values are considered to be in weak head normal form:
-
- - constructor applications
- - literals
- - lambda abstractions
- - type constructor (data/record types) applications
- - function types
- - Set a
-
-Modules
--------
-
-* Modules in import directives
-
- When you use using/hiding/renaming on a name it now automatically applies to
- any module of the same name, unless you explicitly mention the module. For
- instance,
-
- open M using (D)
-
- is equivalent to
-
- open M using (D; module D)
-
- if M defines a module D. This is most useful for record and data types where
- you always get a module of the same name as the type.
-
- With this feature there is no longer useful to be able to qualify a
- constructor (or field) by the name of the data type even when it differs from
- the name of the corresponding module. The follow (weird) code used to work,
- but doesn't work anymore:
-
- module M where
- data D where
- c : D
- open M using (D) renaming (module D to MD)
- foo : D
- foo = D.c
-
- If you want to import only the type name and not the module you have to hide
- it explicitly:
-
- open M using (D) hiding (module D)
-
- See discussion on Issue 836 (https://github.com/agda/agda/issues/836).
-
-* Private definitions of a module are no longer in scope at the Emacs
- mode top-level.
-
- The reason for this change is that .agdai-files are stripped of unused
- private definitions (which can yield significant performance
- improvements for module-heavy code).
-
- To test private definitions you can create a hole at the bottom of the
- module, in which private definitions will be visible.
-
-Records
--------
-
-* New record directives eta-equality/no-eta-equality
-
- The keywords eta-equality/no-eta-equality enable/disable eta rules
- for the (inductive) record type being declared.
-
- record Σ (A : Set) (B : A -> Set) : Set where
- no-eta-equality
- constructor _,_
- field
- fst : A
- snd : B fst
- open Σ
-
- -- fail : ∀ {A : Set}{B : A -> Set} → (x : Σ A B) → x ≡ (fst x , snd x)
- -- fail x = refl
- --
- -- x != fst x , snd x of type Σ .A .B
- -- when checking that the expression refl has type x ≡ (fst x , snd x)
-
-* Building records from modules.
-
- The "record { <fields> }" syntax is now extended to accept module names as
- well. Fields are thus defined using the corresponding definitions from the
- given module.
-
- For instance assuming this record type R and module M:
-
- record R : Set where
- field
- x : X
- y : Y
- z : Z
-
- module M where
- x = {! ... !}
- y = {! ... !}
-
- r : R
- r = record { M; z = {! ... !} }
-
- Previously one had to write `record { x = M.x; y = M.y; z = {! ... !} }`.
-
- More precisely this construction now supports any combination of explicit
- field definitions and applied modules.
-
- If a field is both given explicitly and available in one of the modules,
- then the explicit one takes precedence.
-
- If a field is available in more than one module then this is ambiguous
- and therefore rejected. As a consequence the order of assignments does
- not matter.
-
- The modules can be both applied to arguments and have import directives
- such as `hiding`, `using`, and `renaming`. In particular this construct
- subsumes the record update construction.
-
- Here is an example of record update:
-
- -- Record update. Same as: record r { y = {! ... !} }
- r2 : R
- r2 = record { R r; y = {! ... !} }
-
- A contrived example showing the use of hiding/renaming:
-
- module M2 (a : A) where
- w = {! ... !}
- z = {! ... !}
-
- r3 : A → R
- r3 a = record { M hiding (y); M2 a renaming (w to y) }
-
-* Record patterns are now accepted. Examples:
-
- swap : {A B : Set} (p : A × B) → B × A
- swap record{ proj₁ = a; proj₂ = b } = record{ proj₁ = b; proj₂ = a }
-
- thd3 : ...
- thd3 record{ proj₂ = record { proj₂ = c }} = c
-
-* Record modules now properly hide all their parameters [Issue 1759]
-
- Previously parameters to parent modules were not hidden in the record
- module, resulting in different behaviour between
-
- module M (A : Set) where
- record R (B : Set) : Set where
-
- and
-
- module M where
- record R (A B : Set) : Set where
-
- where in the former case, `A` would be an explicit argument to the module
- `M.R`, but implicit in the latter case. Now `A` is implicit in both cases.
-
-Instance search
----------------
-
-* Performance has been improved, recursive instance search which was previously
- exponential in the depth is now only quadratic.
-
-* Constructors of records and datatypes are not anymore automatically considered
- as instances, you have to do so explicitely, for instance:
-
- -- only [b] is an instance of D
- data D : Set where
- a : D
- instance
- b : D
- c : D
-
- -- the constructor is now an instance
- record tt : Set where
- instance constructor tt
-
-* Lambda-bound variables are no longer automatically considered instances.
-
- Lambda-bound variables need to be bound as instance arguments to be
- considered for instance search. For example,
-
- _==_ : {A : Set} {{_ : Eq A}} → A → A → Bool
-
- fails : {A : Set} → Eq A → A → Bool
- fails eqA x = x == x
-
- works : {A : Set} {{_ : Eq A}} → A → Bool
- works x = x == x
-
-* Let-bound variables are no longer automatically considered instances.
-
- To make a let-bound variable available as an instance it needs to be declared
- with the 'instance' keyword, just like top-level instances. For example,
-
- mkEq : {A : Set} → (A → A → Bool) → Eq A
-
- fails : {A : Set} → (A → A → Bool) → A → Bool
- fails eq x = let eqA = mkEq eq in x == x
-
- works : {A : Set} → (A → A → Bool) → A → Bool
- works eq x = let instance eqA = mkEq eq in x == x
-
-* Record fields can be declared instances.
-
- For example,
-
- record EqSet : Set₁ where
- field
- set : Set
- instance eq : Eq set
-
- This causes the projection function 'eq : (E : EqSet) → Eq (set E)' to be
- considered for instance search.
-
-* Instance search can now find arguments in variable types (but such candidates can
- only be lambda-bound variables, they can’t be declared as instances)
-
- module _ {A : Set} (P : A → Set) where
-
- postulate
- bla : {x : A} {{_ : P x}} → Set → Set
-
- -- Works, the instance argument is found in the context
- test : {x : A} {{_ : P x}} → Set → Set
- test B = bla B
-
- -- Still forbidden, because [P] could be instantiated later to anything
- instance
- postulate
- forbidden : {x : A} → P x
-
-* Instance search now refuses to solve constraints with unconstrained
- metavariables, since this can lead to non-termination.
-
- See [Issue #1532] for an example.
-
-* Top-level instances are now only considered if they are in scope. [Issue #1913]
-
- Note that lambda-bound instances need not be in scope.
-
-Other changes
--------------
-
-* Unicode ellipsis character is allowed for the ellipsis token ... in
- `with` expressions.
-
-* Prop is no longer a reserved word.
-
-Type checking
-=============
-
-* Large indices.
-
- Force constructor arguments no longer count towards the size of a datatype.
- For instance, the definition of equality below is accepted.
-
- data _≡_ {a} {A : Set a} : A → A → Set where
- refl : ∀ x → x ≡ x
-
- This gets rid of the asymmetry that the version of equality which indexes
- only on the second argument could be small, but not the version above which
- indexes on both arguments.
-
-* Detection of datatypes that satisfy K (i.e. sets)
-
- Agda will now try to detect datatypes that satisfy K when --without-K is
- enabled. A datatype satisfies K when it follows these three rules:
-
- - The types of all non-recursive constructor arguments should satisfy K.
-
- - All recursive constructor arguments should be first-order.
-
- - The types of all indices should satisfy K.
-
- For example, the types [Nat], [List Nat], and [x ≡ x] (where x : Nat) are
- all recognized by Agda as satisfying K.
-
-* New unifier for case splitting
-
- The unifier used by Agda for case splitting has been completely rewritten.
- The new unifier takes a much more type-directed approach in order to avoid
- the problems in issues #1406, #1408, #1427, and #1435.
-
- The new unifier also has eta-equality for record types built-in. This should
- avoid unnecessary case splitting on record constructors and improve the
- performance of Agda on code that contains deeply nested record patterns (see
- issues #473, #635, #1575, #1603, #1613, and #1645).
-
- In some cases, the locations of the dot patterns computed by the unifier did
- not correspond to the locations given by the user (see issue #1608). This has
- now been fixed by adding an extra step after case splitting that checks
- whether the user-written patterns are compatible with the computed ones.
-
- In some rare cases, the new unifier is still too restrictive when --without-K
- is enabled because it cannot generalize over the datatype indices (yet). For
- example, the following code is rejected:
-
- data Bar : Set₁ where
- bar : Bar
- baz : (A : Set) → Bar
-
- data Foo : Bar → Set where
- foo : Foo bar
-
- test : foo ≡ foo → Set₁
- test refl = Set
-
-* The aggressive behaviour of `with` introduced in 2.4.2.5 has been
- rolled back [Issue 1692]. With no longer abstracts in the types of
- variables appearing in the with-expressions. [Issue 745]
-
- This means that the following example no longer works:
-
- ```agda
- fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a
- fails f b with a | f b
- fails f b | .b | refl = f b
- ```
-
- The `with` no longer abstracts the type of `f` over `a`, since `f` appears
- in the second with-expression `f b`. You can use a nested `with` to make
- this example work.
-
- This example does work again:
-
- ```agda
- test : ∀{A : Set}{a : A}{f : A → A} (p : f a ≡ a) → f (f a) ≡ a
- test p rewrite p = p
- ```
-
- After `rewrite p` the goal has changed to `f a ≡ a`, but the type
- of `p` has not been rewritten, thus, the final `p` solves the goal.
-
- The following, which worked in 2.4.2.5, no longer works:
-
- ```agda
- fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a
- fails f b rewrite f b = f b
- ```
-
- The rewrite with `f b : a ≡ b` is not applied to `f` as
- the latter is part of the rewrite expression `f b`. Thus,
- the type of `f` remains untouched, and the changed goal
- `b ≡ b` is not solved by `f b`.
-
-* When using `rewrite` on a term `eq` of type `lhs ≡ rhs`, the `lhs`
- is no longer abstracted in `rhs` [Issue 520]. This means that
-
- f pats rewrite eq = body
-
- is more than syntactic sugar for
-
- f pats with lhs | eq
- f pats | _ | refl = body
-
- In particular, the following application of `rewrite` is now
- possible
-
- id : Bool → Bool
- id true = true
- id false = false
-
- is-id : ∀ x → x ≡ id x
- is-id true = refl
- is-id false = refl
-
- postulate
- P : Bool → Set
- b : Bool
- p : P (id b)
-
- proof : P b
- proof rewrite is-id b = p
-
- Previously, this was desugared to
-
- proof with b | is-id b
- proof | _ | refl = p
-
- which did not type check as `refl` does not have type `b ≡ id b`.
- Now, Agda gets the task of checking `refl : _ ≡ id b` leading to
- instantiation of `_` to `id b`.
-
-Compiler backends
-=================
-
-* Major Bug Fixes:
-
- - Function clauses with different arities are now always compiled correctly
- by the GHC/UHC backends. (Issue #727)
-
-* Co-patterns
-
- - The GHC/UHC backends now support co-patterns. (Issues #1567, #1632)
-
-* Optimizations
-
- - Builtin naturals are now represented as arbitrary-precision
- Integers. See the user manual, section
- "Agda Compilers -> Optimizations" for details.
-
-* GHC Haskell backend (MAlonzo)
-
- - Pragmas
-
- Since builtin naturals are compiled to Integer you can no longer
- give a {-# COMPILED_DATA #-} pragma for Nat. The same goes for
- builtin booleans, integers, floats, characters and strings which are now
- hard-wired to appropriate Haskell types.
-
-
-* UHC compiler backend
-
- A new backend targeting the Utrecht Haskell Compiler (UHC) is available.
- It targets the UHC Core language, and it's design is inspired by
- the Epic backend. See the user manual, section
- "Agda Compilers -> UHC Backend" for installation instructions.
-
-
- FFI
-
- The UHC backend has a FFI to Haskell similar to MAlonzo's.
- The target Haskell code also needs to be compilable using UHC,
- which does not support the Haskell base library version 4.*.
-
- FFI pragmas for the UHC backend are not checked in any way. If the pragmas
- are wrong, bad things will happen.
-
- Imports
- Additional Haskell modules can be brought into scope
- with the IMPORT_UHC pragma:
- {-# IMPORT_UHC Data.Char #-}
- The Haskell modules UHC.Base and UHC.Agda.Builtins are always
- in scope and don't need to be imported explicitly.
-
- Datatypes
- Agda datatypes can be bound to Haskell datatypes as follows:
- Haskell:
- data HsData a = HsCon1 | HsCon2 (HsData a)
- Agda:
- data AgdaData (A : Set) : Set where
- AgdaCon1 : AgdaData A
- AgdaCon2 : AgdaData A -> AgdaData A
- {-# COMPILED_DATA_UHC AgdaData HsData HsCon1 HsCon2 #-}
- The mapping has to cover all constructors of the used Haskell datatype,
- else runtime behavior is undefined!
-
- There are special reserved names to bind Agda datatypes to certain Haskell
- datatypes. For example, this binds an Agda datatype
- to Haskell's list datatype:
- Agda:
- data AgdaList (A : Set) : Set where
- Nil : AgdaList A
- Cons : A -> AgdaList A -> AgdaList A
- {-# COMPILED_DATA_UHC AgdaList __LIST__ __NIL__ __CONS__ #-}
-
- The following "magic" datatypes are available:
- HS Datatype | Datatype Pragma | HS Constructor | Constructor Pragma
- () __UNIT__ () __UNIT__
- List __LIST__ (:) __CONS__
- [] __NIL__
- Bool __BOOL__ True __TRUE__
- False __FALSE__
-
- Functions
- Agda postulates can be bound to Haskell functions. Similar as in MAlonzo,
- all arguments of type Set need to be dropped before calling Haskell
- functions. An example calling the return function:
- Agda:
- postulate hs-return : {A : Set} -> A -> IO A
- {-# COMPILED_UHC hs-return (\_ -> UHC.Agda.Builtins.primReturn) #-}
-
-Emacs mode and interaction
-==========================
-
-* Module contents (C-c C-o) now also works for records. [See issue #1926.]
- If you have an inferable expression of record type in an interaction point,
- you can invoke C-c C-o to see its fields and types. Example
-
- record R : Set where
- field f : A
-
- test : R → R
- test r = {!r!} -- C-c C-o here
-
-* Less aggressive error notification.
-
- Previously Emacs could jump to the position of an error even if the
- type-checking process was not initiated in the current buffer. Now
- this no longer happens: If the type-checking process was initiated
- in another buffer, then the cursor is moved to the position of the
- error in the buffer visiting the file (if any) and in every window
- displaying the file, but focus should not change from one file to
- another.
-
- In the cases where focus does change from one file to another, one
- can now use the go-back functionality to return to the previous
- position.
-
-* Removed the agda-include-dirs customization parameter.
-
- Use agda-program-args with -iDIR or -lLIB instead, or add libraries to
- ~/.agda/defaults (C:/Users/USERNAME/AppData/Roaming/agda/defaults or
- similar on Windows). See Library management, above, for more
- information.
-
-Tools
-=====
-
-LaTeX-backend
--------------
-
-* The default font has been changed to XITS (which is part of TeX Live):
-
- http://www.ctan.org/tex-archive/fonts/xits/
-
- This font is more complete with respect to Unicode.
-
-agda-ghc-names
---------------
-
-* New tool: The command
-
- agda-ghc-names fixprof <compile-dir> <ProgName>.prof
-
- converts *.prof files obtained from profiling runs of MAlonzo-compiled
- code to *.agdaIdents.prof, with the original Agda identifiers replacing
- the MAlonzo-generated Haskell identifiers.
-
- For usage and more details, see src/agda-ghc-names/README.txt.
-
-Highlighting and textual backends
-=================================
-
-* Names in import directives are now highlighted and are clickable.
- [Issue 1714]
- This leads also to nicer printing in the LaTeX and html backends.
-
-Fixed issues
-============
-
-See https://github.com/agda/agda/issues?q=milestone%3A2.5.1+is%3Aclosed
-
-------------------------------------------------------------------------
--- Release notes for Agda version 2.4.2.5
-------------------------------------------------------------------------
-
-Important changes since 2.4.2.4:
-
-Installation and infrastructure
-===============================
-
-* Added support for GHC 7.10.3.
-
-* Added `cpphs` Cabal flag
-
- Turn on/off this flag to choose cpphs/cpp as the C preprocessor.
-
- This flag is turn on by default.
-
- (This flag was added in Agda 2.4.2.1 but it was not documented)
-
-Pragmas and options
-===================
-
-* Termination pragmas are no longer allowed inside `where` clauses
- [Issue 1137].
-
-Type checking
-=============
-
-* `with`-abstraction is more aggressive, abstracts also in types of
- variables that are used in the `with`-expressions, unless they are
- also used in the types of the `with`-expressions. [Issue 1692]
-
- Example:
-
- ```agda
- test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a
- test f b with a | f b
- test f b | .b | refl = f b
- ```
-
- Previously, `with` would not abstract in types of variables that
- appear in the `with`-expressions, in this case, both `f` and `b`,
- leaving their types unchanged.
- Now, it tries to abstract in `f`, as only `b` appears in the types of
- the `with`-expressions which are `A` (of `a`) and `a ≡ b` (of `f b`).
- As a result, the type of `f` changes to `(x : A) → b ≡ x` and the
- type of the goal to `b ≡ b` (as previously).
-
- This also affects `rewrite`, which is implemented in terms of
- `with`.
-
- ```agda
- test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a
- test f b rewrite f b = f b
- ```
-
- As the new `with` is not fully backwards-compatible, some parts of
- your Agda developments using `with` or `rewrite` might need
- maintenance.
-
-Fixed issues
-============
-
-See https://github.com/agda/agda/issues
-* 1407
-* 1518
-* 1670
-* 1677
-* 1698
-* 1701
-* 1710
-* 1718
-
-------------------------------------------------------------------------
--- Release notes for Agda version 2.4.2.4
-------------------------------------------------------------------------
-
-Important changes since 2.4.2.3:
-
-Installation and infrastructure
-===============================
-
-* Removed support for GHC 7.4.2.
-
-Pragmas and options
-===================
-
-* Option --copatterns is now on by default. To switch off
- parsing of copatterns, use:
-
- {-# OPTIONS --no-copatterns #-}
-
-* Option --rewriting is now needed to use REWRITE pragmas
- and rewriting during reduction. Rewriting is not --safe.
-
- To use rewriting, first specify a relation symbol `R` that will
- later be used to add rewrite rules. A canonical candidate would be
- propositional equality
-
- {-# BUILTIN REWRITE _≡_ #-}
-
- but any symbol `R` of type `Δ → A → A → Set i` for some `A` and
- `i` is accepted. Then symbols `q` can be added to rewriting
- provided their type is of the form `Γ → R ds l r`. This will add
- a rewrite rule
-
- Γ ⊢ l ↦ r : A[ds/Δ]
-
- to the signature, which fires whenever a term is an instance of `l`.
- For example, if
-
- plus0 : ∀ x → x + 0 ≡ x
-
- (ideally, there is a proof for `plus0`, but it could be a
- postulate), then
-
- {-# REWRITE plus0 #-}
-
- will prompt Agda to rewrite any well-typed term of the form `t + 0`
- to `t`.
-
- Some caveats: Agda accepts and applies rewrite rules naively, it is
- very easy to break consistency and termination of type checking.
- Some examples of rewrite rules that should /not/ be added:
-
- refl : ∀ x → x ≡ x -- Agda loops
- plus-sym : ∀ x y → x + y ≡ y + x -- Agda loops
- absurd : true ≡ false -- Breaks consistency
-
- Adding only proven equations should at least preserve consistency,
- but this is only a conjecture, so know what you are doing!
- Using rewriting, you are entering into the wilderness, where you are
- on your own!
-
-Language
-========
-
-* forall / ∀ now parses like λ, i.e., the following parses now [Issue 1583]:
-
- ⊤ × ∀ (B : Set) → B → B
-
-* The underscore pattern _ can now also stand for an inaccessible
- pattern (dot pattern). This alleviates the need for writing `._'.
- [Issue 1605] Instead of
-
- transVOld : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c
- transVOld _ ._ ._ refl refl = refl
-
- one can now write
-
- transVNew : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c
- transVNew _ _ _ refl refl = refl
-
- and let Agda decide where to put the dots. This was always possible
- by using hidden arguments
-
- transH : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c
- transH refl refl = refl
-
- which is now equivalent to
-
- transHNew : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c
- transHNew {a = _}{b = _}{c = _} refl refl = refl
-
- Before, underscore _ stood for an unnamed variable that could not be
- instantiated by an inaccessible pattern. If one no wants to prevent
- Agda from instantiating, one needs to use a variable name other than
- underscore (however, in practice this situation seems unlikely).
-
-Type checking
-=============
-
-* Polarity of phantom arguments to data and record types has changed. [Issue 1596]
- Polarity of size arguments is Nonvariant (both monotone and antitone).
- Polarity of other arguments is Covariant (monotone).
- Both were Invariant before (neither monotone nor antitone).
-
- The following example type-checks now:
-
- open import Common.Size
-
- -- List should be monotone in both arguments
- -- (even when `cons' is missing).
-
- data List (i : Size) (A : Set) : Set where
- [] : List i A
-
- castLL : ∀{i A} → List i (List i A) → List ∞ (List ∞ A)
- castLL x = x
-
- -- Stream should be antitone in the first and monotone in the second argument
- -- (even with field `tail' missing).
-
- record Stream (i : Size) (A : Set) : Set where
- coinductive
- field
- head : A
-
- castSS : ∀{i A} → Stream ∞ (Stream ∞ A) → Stream i (Stream i A)
- castSS x = x
-
-* SIZELT lambdas must be consistent [Issue 1523, see Abel and Pientka, ICFP 2013].
- When lambda-abstracting over type (Size< size) then size must be
- non-zero, for any valid instantiation of size variables.
-
- The good:
-
- data Nat (i : Size) : Set where
- zero : ∀ (j : Size< i) → Nat i
- suc : ∀ (j : Size< i) → Nat j → Nat i
-
- {-# TERMINATING #-}
- -- This definition is fine, the termination checker is too strict at the moment.
- fix : ∀ {C : Size → Set}
- → (∀ i → (∀ (j : Size< i) → Nat j -> C j) → Nat i → C i)
- → ∀ i → Nat i → C i
- fix t i (zero j) = t i (λ (k : Size< i) → fix t k) (zero j)
- fix t i (suc j n) = t i (λ (k : Size< i) → fix t k) (suc j n)
-
- The λ (k : Size< i) is fine in both cases, as context
-
- i : Size, j : Size< i
-
- guarantees that i is non-zero.
-
- The bad:
-
- record Stream {i : Size} (A : Set) : Set where
- coinductive
- constructor _∷ˢ_
- field
- head : A
- tail : ∀ {j : Size< i} → Stream {j} A
- open Stream public
-
- _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A
- [] ++ˢ s = s
- (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s)
-
- This fails, maybe unjustified, at
-
- i : Size, s : Stream {i} A
- ⊢
- a ∷ˢ (λ {j : Size< i} → as ++ˢ s)
-
- Fixed by defining the constructor by copattern matching:
-
- record Stream {i : Size} (A : Set) : Set where
- coinductive
- field
- head : A
- tail : ∀ {j : Size< i} → Stream {j} A
- open Stream public
-
- _∷ˢ_ : ∀ {i A} → A → Stream {i} A → Stream {↑ i} A
- head (a ∷ˢ as) = a
- tail (a ∷ˢ as) = as
-
- _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A
- [] ++ˢ s = s
- (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s)
-
- The ugly:
-
- fix : ∀ {C : Size → Set}
- → (∀ i → (∀ (j : Size< i) → C j) → C i)
- → ∀ i → C i
- fix t i = t i λ (j : Size< i) → fix t j
-
- For i=0, there is no such j at runtime, leading to looping
- behavior.
-
-Interaction
-===========
-
-* Issue 635 has been fixed. Case splitting does not spit out implicit
- record patterns any more.
-
- record Cont : Set₁ where
- constructor _◃_
- field
- Sh : Set
- Pos : Sh → Set
-
- open Cont
-
- data W (C : Cont) : Set where
- sup : (s : Sh C) (k : Pos C s → W C) → W C
-
- bogus : {C : Cont} → W C → Set
- bogus w = {!w!}
-
- Case splitting on w yielded, since the fix of issue 473,
-
- bogus {Sh ◃ Pos} (sup s k) = ?
-
- Now it gives, as expected,
-
- bogus (sup s k) = ?
-
-Performance
-===========
-
-* As one result of the 21st Agda Implementor's Meeting (AIM XXI),
- serialization of the standard library is 50% faster (time reduced by
- a third), without using additional disk space for the interface
- files.
-
-
-Bug fixes
-=========
-
-* Issues fixed ( see https://github.com/agda/agda/issues ):
- 1546 (copattern matching and with-clauses)
- 1560 (positivity checker inefficiency)
- 1584 (let pattern with trailing implicit)
-
-------------------------------------------------------------------------
--- Release notes for Agda version 2.4.2.3
-------------------------------------------------------------------------
-
-Important changes since 2.4.2.2:
-
-Installation and infrastructure
-===============================
-
-* Added support for GHC 7.10.1.
-
-* Removed support for GHC 7.0.4.
-
-Language
-========
-
-* _ is no longer a valid name for a definition. The following fails now:
- [Issue 1465]
-
- postulate _ : Set
-
-* Typed bindings can now contain hiding information [Issue 1391].
- This means you can now write
-
- assoc : (xs {ys zs} : List A) → ((xs ++ ys) ++ zs) ≡ (xs ++ (ys ++ zs))
-
- instead of the longer
-
- assoc : (xs : List A) {ys zs : List A} → ...
-
- It also works with irrelevance
-
- .(xs {ys zs} : List A) → ...
-
- but of course does not make sense if there is hiding information already.
- Thus, this is (still) a parse error:
-
- {xs {ys zs} : List A} → ...
-
-* The builtins for sized types no longer need accompanying postulates.
- The BUILTIN pragmas for size stuff now also declare the identifiers
- they bind to.
-
- {-# BUILTIN SIZEUNIV SizeUniv #-} -- SizeUniv : SizeUniv
- {-# BUILTIN SIZE Size #-} -- Size : SizeUniv
- {-# BUILTIN SIZELT Size<_ #-} -- Size<_ : ..Size → SizeUniv
- {-# BUILTIN SIZESUC ↑_ #-} -- ↑_ : Size → Size
- {-# BUILTIN SIZEINF ∞ #-} -- ∞ : Size
-
- Size and Size< now live in the new universe SizeUniv.
- It is forbidden to build function spaces in this universe,
- in order to prevent the malicious assumption of a size predecessor
-
- pred : (i : Size) → Size< i
-
- [Issue 1428].
-
-* Unambiguous notations (coming from syntax declarations) that resolve
- to ambiguous names are now parsed unambiguously [Issue 1194].
-
-* If only some instances of an overloaded name have a given
- associated notation (coming from syntax declarations), then this
- name can only be resolved to the given instances of the
- name, not to other instances [Issue 1194].
-
- Previously, if different instances of an overloaded name had
- /different/ associated notations, then none of the notations could
- be used. Now all of them can be used.
-
- Note that notation identity does not only involve the right-hand
- side of the syntax declaration. For instance, the following
- notations are not seen as identical, because the implicit argument
- names are different:
-
- module A where
-
- data D : Set where
- c : {x y : D} → D
-
- syntax c {x = a} {y = b} = a ∙ b
-
- module B where
-
- data D : Set where
- c : {y x : D} → D
-
- syntax c {y = a} {x = b} = a ∙ b
-
-* If an overloaded operator is in scope with at least two distinct
- fixities, then it gets the default fixity [Issue 1436].
-
- Similarly, if two or more identical notations for a given overloaded
- name are in scope, and these notations do not all have the
- same fixity, then they get the default fixity.
-
-Type checking
-=============
-
-* Functions of varying arity can now have with-clauses and use rewrite.
- Example:
-
- NPred : Nat → Set
- NPred 0 = Bool
- NPred (suc n) = Nat → NPred n
-
- const : Bool → ∀{n} → NPred n
- const b {0} = b
- const b {suc n} m = const b {n}
-
- allOdd : ∀ n → NPred n
- allOdd 0 = true
- allOdd (suc n) m with even m
- ... | true = const false
- ... | false = allOdd n
-
-* Function defined by copattern matching can now have with-clauses
- and use rewrite. Example:
-
- {-# OPTIONS --copatterns #-}
-
- record Stream (A : Set) : Set where
- coinductive
- constructor delay
- field
- force : A × Stream A
- open Stream
-
- map : ∀{A B} → (A → B) → Stream A → Stream B
- force (map f s) with force s
- ... | a , as = f a , map f as
-
- record Bisim {A B} (R : A → B → Set) (s : Stream A) (t : Stream B) : Set where
- coinductive
- constructor ~delay
- field
- ~force : let a , as = force s
- b , bs = force t
- in R a b × Bisim R as bs
- open Bisim
-
- SEq : ∀{A} (s t : Stream A) → Set
- SEq = Bisim (_≡_)
-
- -- Slightly weird definition of symmetry to demonstrate rewrite.
-
- ~sym' : ∀{A} {s t : Stream A} → SEq s t → SEq t s
- ~force (~sym' {s = s} {t} p) with force s | force t | ~force p
- ... | a , as | b , bs | r , q rewrite r = refl , ~sym' q
-
-* Instances can now be defined by copattern matching. [Issue 1413]
- The following example extends the one in
- [Abel, Pientka, Thibodeau, Setzer, POPL 2013, Section 2.2]:
-
- {-# OPTIONS --copatterns #-}
-
- -- The Monad type class
-
- record Monad (M : Set → Set) : Set1 where
- field
- return : {A : Set} → A → M A
- _>>=_ : {A B : Set} → M A → (A → M B) → M B
- open Monad {{...}}
-
- -- The State newtype
-
- record State (S A : Set) : Set where
- field
- runState : S → A × S
- open State
-
- -- State is an instance of Monad
-
- instance
- stateMonad : {S : Set} → Monad (State S)
- runState (return {{stateMonad}} a ) s = a , s -- NEW
- runState (_>>=_ {{stateMonad}} m k) s₀ = -- NEW
- let a , s₁ = runState m s₀
- in runState (k a) s₁
-
- -- stateMonad fulfills the monad laws
-
- leftId : {A B S : Set}(a : A)(k : A → State S B) →
- (return a >>= k) ≡ k a
- leftId a k = refl
-
- rightId : {A B S : Set}(m : State S A) →
- (m >>= return) ≡ m
- rightId m = refl
-
- assoc : {A B C S : Set}(m : State S A)(k : A → State S B)(l : B → State S C) →
- ((m >>= k) >>= l) ≡ (m >>= λ a → k a >>= l)
- assoc m k l = refl
-
-
-Emacs mode
-==========
-
-* The new menu option "Switch to another version of Agda" tries to do
- what it says.
-
-* Changed feature: Interactively split result.
-
- [ This is as before: ]
- Make-case (C-c C-c) with no variables given tries to split on the
- result to introduce projection patterns. The hole needs to be of
- record type, of course.
-
- test : {A B : Set} (a : A) (b : B) → A × B
- test a b = ?
-
- Result-splitting ? will produce the new clauses:
-
- proj₁ (test a b) = ?
- proj₂ (test a b) = ?
-
- [ This has changed: ]
- If hole is of function type, make-case will introduce only pattern
- variables (as much as it can).
-
- testFun : {A B : Set} (a : A) (b : B) → A × B
- testFun = ?
-
- Result-splitting ? will produce the new clause:
-
- testFun a b = ?
-
- A second invocation of make-case will then introduce projection patterns.
-
-Error messages
-==============
-
-* Agda now suggests corrections of misspelled options, e.g.
-
- {-# OPTIONS
- --dont-termination-check
- --without-k
- --senf-gurke
- #-}
-
- Unrecognized options:
- --dont-termination-check (did you mean --no-termination-check ?)
- --without-k (did you mean --without-K ?)
- --senf-gurke
-
- Nothing close to --senf-gurke, I am afraid.
-
-Compiler backends
-=================
-
-* The Epic backend has been removed [Issue 1481].
-
-Bug fixes
-=========
-
-* Fixed bug with unquoteDecl not working in instance blocks [Issue 1491].
-
-* Other issues fixed ( see https://code.google.com/p/agda/issues )
- 1497
- 1500
-
-------------------------------------------------------------------------
--- Release notes for Agda version 2.4.2.2
-------------------------------------------------------------------------
-
-Important changes since 2.4.2.1:
-
-Bug fixes
-=========
-
-* Compilation on Windows fixed.
-
-* Other issues fixed ( see https://code.google.com/p/agda/issues )
- 1332
- 1353
- 1360
- 1366
- 1369
-
-------------------------------------------------------------------------
--- Release notes for Agda version 2.4.2.1
-------------------------------------------------------------------------
-
-Important changes since 2.4.2:
-
-Pragmas and options
-===================
-
-* New pragma {-# TERMINATING #-} replacing {-# NO_TERMINATION_CHECK #-}
-
- Complements the existing pragma {-# NON_TERMINATING #-}.
- Skips termination check for the associated definitions and marks
- them as terminating. Thus, it is a replacement for
- {-# NO_TERMINATION_CHECK #-} with the same semantics.
-
- You can no longer use pragma {-# NO_TERMINATION_CHECK #-} to skip
- the termination check, but must label your definitions as either
- {-# TERMINATING #-} or {-# NON_TERMINATING #-} instead.
-
- Note: {-# OPTION --no-termination-check #-} labels all your
- definitions as {-# TERMINATING #-}, putting you in the danger zone
- of a loop in the type checker.
-
-Language
-========
-
-* Referring to a local variable shadowed by module opening is now
- an error. Previous behavior was preferring the local over the
- imported definitions. [Issue 1266]
-
- Note that module parameters are locals as well as variables bound by
- λ, dependent function type, patterns, and let.
-
- Example:
-
- module M where
- A = Set1
-
- test : (A : Set) → let open M in A
-
- The last A produces an error, since it could refer to the local
- variable A or to the definition imported from module M.
-
-* `with` on a variable bound by a module telescope or a pattern of a
- parent function is now forbidden. [Issue 1342]
-
- data Unit : Set where
- unit : Unit
-
- id : (A : Set) → A → A
- id A a = a
-
- module M (x : Unit) where
-
- dx : Unit → Unit
- dx unit = x
-
- g : ∀ u → x ≡ dx u
- g with x
- g | unit = id (∀ u → unit ≡ dx u) ?
-
- Even though this code looks right, Agda complains about the type
- expression `∀ u → unit ≡ dx u`. If you ask Agda what should go
- there instead, it happily tells you that it wants
- `∀ u → unit ≡ dx u`. In fact what you do not see and Agda
- will never show you is that the two expressions actually differ in
- the invisible first argument to `dx`, which is visible only outside
- module `M`. What Agda wants is an invisible `unit` after `dx`, but all
- you can write is an invisible `x` (which is inserted behind the
- scenes).
-
- To avoid those kinds of paradoxes, `with` is now outlawed on module
- parameters. This should ensure that the invisible arguments are
- always exactly the module parameters.
-
- Since a `where` block is desugared as module with pattern variables
- of the parent clause as module parameters, the same strikes you for
- uses of `with` on pattern variables of the parent function.
-
- f : Unit → Unit
- f x = unit
- where
- dx : Unit → Unit
- dx unit = x
-
- g : ∀ u → x ≡ dx u
- g with x
- g | unit = id ((u : Unit) → unit ≡ dx u) ?
-
- The `with` on pattern variable `x` of the parent clause `f x = unit`
- is outlawed now.
-
-Type checking
-=============
-
-* Termination check failure is now a proper error.
-
- We no longer continue type checking after termination check failures.
- Use pragmas {-# NON_TERMINATING #-} and {-# NO_TERMINATION_CHECK #-}
- near the offending definitions if you want to do so.
- Or switch off the termination checker altogether with
- {-# OPTIONS --no-termination-check #-} (at your own risk!).
-
-* (Since Agda 2.4.2:) Termination checking --without-K restricts
- structural descent to arguments ending in data types or `Size`.
- Likewise, guardedness is only tracked when result type is data or
- record type.
-
- mutual
- data WOne : Set where wrap : FOne → WOne
- FOne = ⊥ → WOne
-
- noo : (X : Set) → (WOne ≡ X) → X → ⊥
- noo .WOne refl (wrap f) = noo FOne iso f
-
- `noo` is rejected since at type `X` the structural descent
- `f < wrap f` is discounted --without-K.
-
- data Pandora : Set where
- C : ∞ ⊥ → Pandora
-
- loop : (A : Set) → A ≡ Pandora → A
- loop .Pandora refl = C (♯ (loop ⊥ foo))
-
- `loop` is rejected since guardedness is not tracked at type `A`
- --without-K.
-
- See issues 1023, 1264, 1292.
-
-Termination checking
-====================
-
-* The termination checker can now recognize simple subterms in dot
- patterns.
-
- data Subst : (d : Nat) → Set where
- c₁ : ∀ {d} → Subst d → Subst d
- c₂ : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (suc d₁ + d₂)
-
- postulate
- comp : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (d₁ + d₂)
-
- lookup : ∀ d → Nat → Subst d → Set₁
- lookup d zero (c₁ ρ) = Set
- lookup d (suc v) (c₁ ρ) = lookup d v ρ
- lookup .(suc d₁ + d₂) v (c₂ {d₁} {d₂} ρ σ) = lookup (d₁ + d₂) v (comp ρ σ)
-
- The dot pattern here is actually normalized, so it is
-
- suc (d₁ + d₂)
-
- and the corresponding recursive call argument is (d₁ + d₂).
- In such simple cases, Agda can now recognize that the pattern is
- constructor applied to call argument, which is valid descent.
-
- Note however, that Agda only looks for syntactic equality when
- identifying subterms, since it is not allowed to normalize terms on
- the rhs during termination checking.
-
- Actually writing the dot pattern has no effect, this works as well,
- and looks pretty magical... ;-)
-
- hidden : ∀{d} → Nat → Subst d → Set₁
- hidden zero (c₁ ρ) = Set
- hidden (suc v) (c₁ ρ) = hidden v ρ
- hidden v (c₂ ρ σ) = hidden v (comp ρ σ)
-
-Tools
-=====
-
-LaTeX-backend
--------------
-
-* Fixed the issue of identifiers containing operators being typeset with
- excessive math spacing.
-
-Bug fixes
-=========
-
-* Issue 1194
-
-* Issue 836: Fields and constructors can be qualified by the
- record/data *type* as well as by their record/data module.
- This now works also for record/data type imported from
- parametrized modules:
-
- module M (_ : Set₁) where
-
- record R : Set₁ where
- field
- X : Set
-
- open M Set using (R) -- rather than using (module R)
-
- X : R → Set
- X = R.X
-
-------------------------------------------------------------------------
--- Release notes for Agda version 2.4.2
-------------------------------------------------------------------------
-
-Important changes since 2.4.0.2:
-
-Pragmas and options
-===================
-
-* New option: --with-K.
-
- This can be used to override a global --without-K in a file, by
- adding a pragma {-# OPTIONS --with-K #-}.
-
-* New pragma {-# NON_TERMINATING #-}
-
- This is a safer version of NO_TERMINATION_CHECK which doesn't treat the
- affected functions as terminating. This means that NON_TERMINATING functions
- do not reduce during type checking. They do reduce at run-time and when
- invoking C-c C-n at top-level (but not in a hole).
-
-Language
-========
-
-* Instance search is now more efficient and recursive (see issue 938)
- (but without termination check yet).
-
- A new keyword `instance' has been introduced (in the style of
- `abstract' and `private') which must now be used for every
- definition/postulate that has to be taken into account during instance
- resolution. For example:
-
- record RawMonoid (A : Set) : Set where
- field
- nil : A
- _++_ : A -> A -> A
-
- open RawMonoid {{...}}
-
- instance
- rawMonoidList : {A : Set} -> RawMonoid (List A)
- rawMonoidList = record { nil = []; _++_ = List._++_ }
-
- rawMonoidMaybe : {A : Set} {{m : RawMonoid A}} -> RawMonoid (Maybe A)
- rawMonoidMaybe {A} = record { nil = nothing ; _++_ = catMaybe }
- where
- catMaybe : Maybe A -> Maybe A -> Maybe A
- catMaybe nothing mb = mb
- catMaybe ma nothing = ma
- catMaybe (just a) (just b) = just (a ++ b)
-
- Moreover, each type of an instance must end in (something that reduces
- to) a named type (e.g. a record, a datatype or a postulate). This
- allows us to build a simple index structure
-
- data/record name --> possible instances
-
- that speeds up instance search.
-
- Instance search takes into account all local bindings and all global
- 'instance' bindings and the search is recursive. For instance,
- searching for
-
- ? : RawMonoid (Maybe (List A))
-
- will consider the candidates {rawMonoidList, rawMonoidMaybe}, fail to
- unify the first one, succeeding with the second one
-
- ? = rawMonoidMaybe {A = List A} {{m = ?m}} : RawMonoid (Maybe (List A))
-
- and continue with goal
-
- ?m : RawMonoid (List A)
-
- This will then find
-
- ?m = rawMonoidList {A = A}
-
- and putting together we have the solution.
-
- Be careful that there is no termination check for now, you can easily
- make Agda loop by declaring the identity function as an instance. But
- it shouldn’t be possible to make Agda loop by only declaring
- structurally recursive instances (whatever that means).
-
- Additionally:
-
- * Uniqueness of instances is up to definitional equality (see issue 899).
-
- * Instances of the following form are allowed:
-
- EqSigma : {A : Set} {B : A → Set} {{EqA : Eq A}}
- {{EqB : {a : A} → Eq (B a)}}
- → Eq (Σ A B)
-
- When searching recursively for an instance of type
- `{a : A} → Eq (B a)', a lambda will automatically be introduced and
- instance search will search for something of type `Eq (B a)' in
- the context extended by `a : A'. When searching for an instance, the
- `a' argument does not have to be implicit, but in the definition of
- EqSigma, instance search will only be able to use EqB if `a' is implicit.
-
- * There is no longer any attempt to solve irrelevant metas by instance
- search.
-
- * Constructors of records and datatypes are automatically added to the
- instance table.
-
-* You can now use 'quote' in patterns.
-
- For instance, here is a function that unquotes a (closed) natural number
- term.
-
- unquoteNat : Term → Maybe Nat
- unquoteNat (con (quote Nat.zero) []) = just zero
- unquoteNat (con (quote Nat.suc) (arg _ n ∷ [])) = fmap suc (unquoteNat n)
- unquoteNat _ = nothing
-
-* The builtin constructors AGDATERMUNSUPPORTED and AGDASORTUNSUPPORTED are now
- translated to meta variables when unquoting.
-
-* New syntactic sugar 'tactic e' and 'tactic e | e1 | .. | en'.
-
- It desugars as follows and makes it less unwieldy to call reflection-based
- tactics.
-
- tactic e --> quoteGoal g in unquote (e g)
- tactic e | e1 | .. | en --> quoteGoal g in unquote (e g) e1 .. en
-
- Note that in the second form the tactic function should generate a function
- from a number of new subgoals to the original goal. The type of e should be
- Term -> Term in both cases.
-
-* New reflection builtins for literals.
-
- The Term data type AGDATERM now needs an additional constructor AGDATERMLIT
- taking a reflected literal defined as follows (with appropriate builtin
- bindings for the types Nat, Float, etc).
-
- data Literal : Set where
- nat : Nat → Literal
- float : Float → Literal
- char : Char → Literal
- string : String → Literal
- qname : QName → Literal
-
- {-# BUILTIN AGDALITERAL Literal #-}
- {-# BUILTIN AGDALITNAT nat #-}
- {-# BUILTIN AGDALITFLOAT float #-}
- {-# BUILTIN AGDALITCHAR char #-}
- {-# BUILTIN AGDALITSTRING string #-}
- {-# BUILTIN AGDALITQNAME qname #-}
-
- When quoting (quoteGoal or quoteTerm) literals will be mapped to the
- AGDATERMLIT constructor. Previously natural number literals were quoted
- to suc/zero application and other literals were quoted to
- AGDATERMUNSUPPORTED.
-
-* New reflection builtins for function definitions.
-
- AGDAFUNDEF should now map to a data type defined as follows
- (with {-# BUILTIN QNAME QName #-}
- {-# BUILTIN ARG Arg #-}
- {-# BUILTIN AGDATERM Term #-}
- {-# BUILTIN AGDATYPE Type #-}
- {-# BUILTIN AGDALITERAL Literal #-}).
-
- data Pattern : Set where
- con : QName → List (Arg Pattern) → Pattern
- dot : Pattern
- var : Pattern
- lit : Literal → Pattern
- proj : QName → Pattern
- absurd : Pattern
-
- {-# BUILTIN AGDAPATTERN Pattern #-}
- {-# BUILTIN AGDAPATCON con #-}
- {-# BUILTIN AGDAPATDOT dot #-}
- {-# BUILTIN AGDAPATVAR var #-}
- {-# BUILTIN AGDAPATLIT lit #-}
- {-# BUILTIN AGDAPATPROJ proj #-}
- {-# BUILTIN AGDAPATABSURD absurd #-}
-
- data Clause : Set where
- clause : List (Arg Pattern) → Term → Clause
- absurd-clause : List (Arg Pattern) → Clause
-
- {-# BUILTIN AGDACLAUSE Clause #-}
- {-# BUILTIN AGDACLAUSECLAUSE clause #-}
- {-# BUILTIN AGDACLAUSEABSURD absurd-clause #-}
-
- data FunDef : Set where
- fun-def : Type → List Clause → FunDef
-
- {-# BUILTIN AGDAFUNDEF FunDef #-}
- {-# BUILTIN AGDAFUNDEFCON fun-def #-}
-
-* New reflection builtins for extended (pattern-matching) lambda.
-
- The AGDATERM data type has been augmented with a constructor
-
- AGDATERMEXTLAM : List AGDACLAUSE → List (ARG AGDATERM) → AGDATERM
-
- Absurd lambdas (λ ()) are quoted to extended lambdas with an absurd clause.
-
-* Unquoting declarations.
-
- You can now define (recursive) functions by reflection using the new
- unquoteDecl declaration
-
- unquoteDecl x = e
-
- Here e should have type AGDAFUNDEF and evaluate to a closed value. This value
- is then spliced in as the definition of x. In the body e, x has type QNAME
- which lets you splice in recursive definitions.
-
- Standard modifiers, such as fixity declarations, can be applied to x as
- expected.
-
-* Quoted levels
-
- Universe levels are now quoted properly instead of being quoted to
- AGDASORTUNSUPPORTED. Setω still gets an unsupported sort, however.
-
-* Module applicants can now be operator applications. Example:
-
- postulate
- [_] : A -> B
-
- module M (b : B) where
-
- module N (a : A) = M [ a ]
-
- [See Issue 1245.]
-
-* Minor change in module application semantics. [Issue 892]
-
- Previously re-exported functions were not redefined when instantiating a
- module. For instance
-
- module A where f = ...
- module B (X : Set) where
- open A public
- module C = B Nat
-
- In this example C.f would be an alias for A.f, so if both A and C were opened
- f would not be ambiguous. However, this behaviour is not correct when A and B
- share some module parameters (issue 892). To fix this C now defines its own
- copy of f (which evaluates to A.f), which means that opening A and C results
- in an ambiguous f.
-
-Type checking
-=============
-
-* Recursive records need to be declared as either inductive or coinductive.
- 'inductive' is no longer default for recursive records.
- Examples:
-
- record _×_ (A B : Set) : Set where
- constructor _,_
- field
- fst : A
- snd : B
-
- record Tree (A : Set) : Set where
- inductive
- constructor tree
- field
- elem : A
- subtrees : List (Tree A)
-
- record Stream (A : Set) : Set where
- coinductive
- constructor _::_
- field
- head : A
- tail : Stream A
-
- If you are using old-style (musical) coinduction, a record may have
- to be declared as inductive, paradoxically.
-
- record Stream (A : Set) : Set where
- inductive -- YES, THIS IS INTENDED !
- constructor _∷_
- field
- head : A
- tail : ∞ (Stream A)
-
- This is because the ``coinduction'' happens in the use of `∞' and not
- in the use of `record'.
-
-Tools
-=====
-
-Emacs mode
-----------
-
-* A new menu option "Display" can be used to display the version of
- the running Agda process.
-
-LaTeX-backend
--------------
-
-* New experimental option ``references'' has been added. When specified,
- i.e.:
-
- \usepackage[references]{agda}
-
- a new command called \AgdaRef is provided, which lets you reference
- previously typeset commands, e.g.:
-
- Let us postulate \AgdaRef{apa}.
-
- \begin{code}
- postulate
- apa : Set
- \end{code}
-
- Above ``apa'' will be typeset (highlighted) the same in the text as in
- the code, provided that the LaTeX output is post-processed using
- src/data/postprocess-latex.pl, e.g.:
-
- cp $(dirname $(dirname $(agda-mode locate)))/postprocess-latex.pl .
- agda -i. --latex Example.lagda
- cd latex/
- perl ../postprocess-latex.pl Example.tex > Example.processed
- mv Example.processed Example.tex
- xelatex Example.tex
-
- Mix-fix and unicode should work as expected (unicode requires
- XeLaTeX/LuaLaTeX), but there are limitations:
-
- + Overloading identifiers should be avoided, if multiples exist
- \AgdaRef will typeset according to the first it finds.
-
- + Only the current module is used, should you need to reference
- identifiers in other modules then you need to specify which other
- module manually, i.e. \AgdaRef[module]{identifier}.
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.4.0.2
-------------------------------------------------------------------------
-
-Important changes since 2.4.0.1:
-
-* The Agda input mode now supports alphabetical super and subscripts,
- in addition to the numerical ones that were already present.
- [Issue 1240]
-
-* New feature: Interactively split result.
-
- Make case (C-c C-c) with no variables given tries to split on the
- result to introduce projection patterns. The hole needs to be of
- record type, of course.
-
- test : {A B : Set} (a : A) (b : B) → A × B
- test a b = ?
-
- Result-splitting ? will produce the new clauses:
-
- proj₁ (test a b) = ?
- proj₂ (test a b) = ?
-
- If hole is of function type ending in a record type, the necessary
- pattern variables will be introduced before the split. Thus, the
- same result can be obtained by starting from:
-
- test : {A B : Set} (a : A) (b : B) → A × B
- test = ?
-
-* The so far undocumented ETA pragma now throws an error if applied to
- definitions that are not records.
-
- ETA can be used to force eta-equality at recursive record types,
- for which eta is not enabled automatically by Agda.
- Here is such an example:
-
- mutual
- data Colist (A : Set) : Set where
- [] : Colist A
- _∷_ : A → ∞Colist A → Colist A
-
- record ∞Colist (A : Set) : Set where
- coinductive
- constructor delay
- field force : Colist A
-
- open ∞Colist
-
- {-# ETA ∞Colist #-}
-
- test : {A : Set} (x : ∞Colist A) → x ≡ delay (force x)
- test x = refl
-
- Note: Unsafe use of ETA can make Agda loop, e.g. by triggering
- infinite eta expansion!
-
-* Bugs fixed (see https://code.google.com/p/agda/issues):
- 1203
- 1205
- 1209
- 1213
- 1214
- 1216
- 1225
- 1226
- 1231
- 1233
- 1239
- 1241
- 1243
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.4.0.1
-------------------------------------------------------------------------
-
-Important changes since 2.4.0:
-
-* The option --compile-no-main has been renamed to --no-main.
-
-* COMPILED_DATA pragmas can now be given for records.
-
-* Various bug fixes.
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.4.0
-------------------------------------------------------------------------
-
-Important changes since 2.3.2.2:
-
-Installation and infrastructure
-===============================
-
-* A new module called Agda.Primitive has been introduced. This module
- is available to all users, even if the standard library is not used.
- Currently the module contains level primitives and their
- representation in Haskell when compiling with MAlonzo:
-
- infixl 6 _⊔_
-
- postulate
- Level : Set
- lzero : Level
- lsuc : (ℓ : Level) → Level
- _⊔_ : (ℓ₁ ℓ₂ : Level) → Level
-
- {-# COMPILED_TYPE Level () #-}
- {-# COMPILED lzero () #-}
- {-# COMPILED lsuc (\_ -> ()) #-}
- {-# COMPILED _⊔_ (\_ _ -> ()) #-}
-
- {-# BUILTIN LEVEL Level #-}
- {-# BUILTIN LEVELZERO lzero #-}
- {-# BUILTIN LEVELSUC lsuc #-}
- {-# BUILTIN LEVELMAX _⊔_ #-}
-
- To bring these declarations into scope you can use a declaration
- like the following one:
-
- open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-
- The standard library reexports these primitives (using the names
- zero and suc instead of lzero and lsuc) from the Level module.
-
- Existing developments using universe polymorphism might now trigger
- the following error message:
-
- Duplicate binding for built-in thing LEVEL, previous binding to
- .Agda.Primitive.Level
-
- To fix this problem, please remove the duplicate bindings.
-
- Technical details (perhaps relevant to those who build Agda
- packages):
-
- The include path now always contains a directory <DATADIR>/lib/prim,
- and this directory is supposed to contain a subdirectory Agda
- containing a file Primitive.agda.
-
- The standard location of <DATADIR> is system- and
- installation-specific. E.g., in a cabal --user installation of
- Agda-2.3.4 on a standard single-ghc Linux system it would be
- $HOME/.cabal/share/Agda-2.3.4 or something similar.
-
- The location of the <DATADIR> directory can be configured at
- compile-time using Cabal flags (--datadir and --datasubdir).
- The location can also be set at run-time, using the Agda_datadir
- environment variable.
-
-Pragmas and options
-===================
-
-* Pragma NO_TERMINATION_CHECK placed within a mutual block is now
- applied to the whole mutual block (rather than being discarded
- silently). Adding to the uses 1.-4. outlined in the release notes
- for 2.3.2 we allow:
-
- 3a. Skipping an old-style mutual block: Somewhere within 'mutual'
- block before a type signature or first function clause.
-
- mutual
- {-# NO_TERMINATION_CHECK #-}
- c : A
- c = d
-
- d : A
- d = c
-
-* New option --no-pattern-matching
-
- Disables all forms of pattern matching (for the current file).
- You can still import files that use pattern matching.
-
-* New option -v profile:7
-
- Prints some stats on which phases Agda spends how much time.
- (Number might not be very reliable, due to garbage collection
- interruptions, and maybe due to laziness of Haskell.)
-
-* New option --no-sized-types
-
- Option --sized-types is now default.
- --no-sized-types will turn off an extra (inexpensive) analysis on
- data types used for subtyping of sized types.
-
-Language
-========
-
-* Experimental feature: quoteContext
-
- There is a new keyword 'quoteContext' that gives users access to the
- list of names in the current local context. For instance:
-
- open import Data.Nat
- open import Data.List
- open import Reflection
-
- foo : ℕ → ℕ → ℕ
- foo 0 m = 0
- foo (suc n) m = quoteContext xs in ?
-
- In the remaining goal, the list xs will consist of two names, n and
- m, corresponding to the two local variables. At the moment it is not
- possible to access let bound variables -- this feature may be added
- in the future.
-
-* Experimental feature: Varying arity.
- Function clauses may now have different arity, e.g.,
-
- Sum : ℕ → Set
- Sum 0 = ℕ
- Sum (suc n) = ℕ → Sum n
-
- sum : (n : ℕ) → ℕ → Sum n
- sum 0 acc = acc
- sum (suc n) acc m = sum n (m + acc)
-
- or,
-
- T : Bool → Set
- T true = Bool
- T false = Bool → Bool
-
- f : (b : Bool) → T b
- f false true = false
- f false false = true
- f true = true
-
- This feature is experimental. Yet unsupported:
- * Varying arity and 'with'.
- * Compilation of functions with varying arity to Haskell, JS, or Epic.
-
-* Experimental feature: copatterns. (Activated with option --copatterns)
-
- We can now define a record by explaining what happens if you project
- the record. For instance:
-
- {-# OPTIONS --copatterns #-}
-
- record _×_ (A B : Set) : Set where
- constructor _,_
- field
- fst : A
- snd : B
- open _×_
-
- pair : {A B : Set} → A → B → A × B
- fst (pair a b) = a
- snd (pair a b) = b
-
- swap : {A B : Set} → A × B → B × A
- fst (swap p) = snd p
- snd (swap p) = fst p
-
- swap3 : {A B C : Set} → A × (B × C) → C × (B × A)
- fst (swap3 t) = snd (snd t)
- fst (snd (swap3 t)) = fst (snd t)
- snd (snd (swap3 t)) = fst t
-
- Taking a projection on the left hand side (lhs) is called a
- projection pattern, applying to a pattern is called an application
- pattern. (Alternative terms: projection/application copattern.)
-
- In the first example, the symbol 'pair', if applied to variable
- patterns a and b and then projected via fst, reduces to a.
- 'pair' by itself does not reduce.
-
- A typical application are coinductive records such as streams:
-
- record Stream (A : Set) : Set where
- coinductive
- field
- head : A
- tail : Stream A
- open Stream
-
- repeat : {A : Set} (a : A) -> Stream A
- head (repeat a) = a
- tail (repeat a) = repeat a
-
- Again, 'repeat a' by itself will not reduce, but you can take
- a projection (head or tail) and then it will reduce to the
- respective rhs. This way, we get the lazy reduction behavior
- necessary to avoid looping corecursive programs.
-
- Application patterns do not need to be trivial (i.e., variable
- patterns), if we mix with projection patterns. E.g., we can have
-
- nats : Nat -> Stream Nat
- head (nats zero) = zero
- tail (nats zero) = nats zero
- head (nats (suc x)) = x
- tail (nats (suc x)) = nats x
-
- Here is an example (not involving coinduction) which demostrates
- records with fields of function type:
-
- -- The State monad
-
- record State (S A : Set) : Set where
- constructor state
- field
- runState : S → A × S
- open State
-
- -- The Monad type class
-
- record Monad (M : Set → Set) : Set1 where
- constructor monad
- field
- return : {A : Set} → A → M A
- _>>=_ : {A B : Set} → M A → (A → M B) → M B
-
-
- -- State is an instance of Monad
- -- Demonstrates the interleaving of projection and application patterns
-
- stateMonad : {S : Set} → Monad (State S)
- runState (Monad.return stateMonad a ) s = a , s
- runState (Monad._>>=_ stateMonad m k) s₀ =
- let a , s₁ = runState m s₀
- in runState (k a) s₁
-
- module MonadLawsForState {S : Set} where
-
- open Monad (stateMonad {S})
-
- leftId : {A B : Set}(a : A)(k : A → State S B) →
- (return a >>= k) ≡ k a
- leftId a k = refl
-
- rightId : {A B : Set}(m : State S A) →
- (m >>= return) ≡ m
- rightId m = refl
-
- assoc : {A B C : Set}(m : State S A)(k : A → State S B)(l : B → State S C) →
- ((m >>= k) >>= l) ≡ (m >>= λ a → (k a >>= l))
- assoc m k l = refl
-
- Copatterns are yet experimental and the following does not work:
-
- * Copatterns and 'with' clauses.
-
- * Compilation of copatterns to Haskell, JS, or Epic.
-
- * Projections generated by
- open R {{...}}
- are not handled properly on lhss yet.
-
- * Conversion checking is slower in the presence of copatterns,
- since stuck definitions of record type do no longer count
- as neutral, since they can become unstuck by applying a projection.
- Thus, comparing two neutrals currently requires comparing all
- they projections, which repeats a lot of work.
-
-* Top-level module no longer required.
-
- The top-level module can be omitted from an Agda file. The module name is
- then inferred from the file name by dropping the path and the .agda
- extension. So, a module defined in /A/B/C.agda would get the name C.
-
- You can also suppress only the module name of the top-level module by writing
-
- module _ where
-
- This works also for parameterised modules.
-
-* Module parameters are now always hidden arguments in projections.
- For instance:
-
- module M (A : Set) where
-
- record Prod (B : Set) : Set where
- constructor _,_
- field
- fst : A
- snd : B
- open Prod public
-
- open M
-
- Now, the types of fst and snd are
-
- fst : {A : Set}{B : Set} → Prod A B → A
- snd : {A : Set}{B : Set} → Prod A B → B
-
- Until 2.3.2, they were
-
- fst : (A : Set){B : Set} → Prod A B → A
- snd : (A : Set){B : Set} → Prod A B → B
-
- This change is a step towards symmetry of constructors and projections.
- (Constructors always took the module parameters as hidden arguments).
-
-* Telescoping lets: Local bindings are now accepted in telescopes
- of modules, function types, and lambda-abstractions.
-
- The syntax of telescopes as been extended to support 'let':
-
- id : (let ★ = Set) (A : ★) → A → A
- id A x = x
-
- In particular one can now 'open' modules inside telescopes:
-
- module Star where
- ★ : Set₁
- ★ = Set
-
- module MEndo (let open Star) (A : ★) where
- Endo : ★
- Endo = A → A
-
- Finally a shortcut is provided for opening modules:
-
- module N (open Star) (A : ★) (open MEndo A) (f : Endo) where
- ...
-
- The semantics of the latter is
-
- module _ where
- open Star
- module _ (A : ★) where
- open MEndo A
- module N (f : Endo) where
- ...
-
- The semantics of telescoping lets in function types and lambda
- abstractions is just expanding them into ordinary lets.
-
-* More liberal left-hand sides in lets [Issue 1028]:
-
- You can now write left-hand sides with arguments also for let bindings
- without a type signature. For instance,
-
- let f x = suc x in f zero
-
- Let bound functions still can't do pattern matching though.
-
-* Ambiguous names in patterns are now optimistically resolved in favor
- of constructors. [Issue 822] In particular, the following succeeds now:
-
- module M where
-
- data D : Set₁ where
- [_] : Set → D
-
- postulate [_] : Set → Set
-
- open M
-
- Foo : _ → Set
- Foo [ A ] = A
-
-* Anonymous where-modules are opened public. [Issue 848]
-
- <clauses>
- f args = rhs
- module _ telescope where
- body
- <more clauses>
-
- means the following (not proper Agda code, since you cannot put a
- module in-between clauses)
-
- <clauses>
- module _ {arg-telescope} telescope where
- body
-
- f args = rhs
- <more clauses>
-
- Example:
-
- A : Set1
- A = B module _ where
- B : Set1
- B = Set
-
- C : Set1
- C = B
-
-* Builtin ZERO and SUC have been merged with NATURAL.
-
- When binding the NATURAL builtin, ZERO and SUC are bound to the appropriate
- constructors automatically. This means that instead of writing
-
- {-# BUILTIN NATURAL Nat #-}
- {-# BUILTIN ZERO zero #-}
- {-# BUILTIN SUC suc #-}
-
- you just write
-
- {-# BUILTIN NATURAL Nat #-}
-
-* Pattern synonym can now have implicit arguments. [Issue 860]
-
- For example,
-
- pattern tail=_ {x} xs = x ∷ xs
-
- len : ∀ {A} → List A → Nat
- len [] = 0
- len (tail= xs) = 1 + len xs
-
-* Syntax declarations can now have implicit arguments. [Issue 400]
-
- For example
-
- id : ∀ {a}{A : Set a} -> A -> A
- id x = x
-
- syntax id {A} x = x ∈ A
-
-* Minor syntax changes
-
- * -} is now parsed as end-comment even if no comment was begun.
- As a consequence, the following definition gives a parse error
-
- f : {A- : Set} -> Set
- f {A-} = A-
-
- because Agda now sees ID(f) LBRACE ID(A) END-COMMENT, and no
- longer ID(f) LBRACE ID(A-) RBRACE.
-
- The rational is that the previous lexing was to context-sensitive,
- attempting to comment-out f using {- and -} lead to a parse error.
-
- * Fixities (binding strengths) can now be negative numbers as
- well. [Issue 1109]
-
- infix -1 _myop_
-
- * Postulates are now allowed in mutual blocks. [Issue 977]
-
- * Empty where blocks are now allowed. [Issue 947]
-
- * Pattern synonyms are now allowed in parameterised modules. [Issue 941]
-
- * Empty hiding and renaming lists in module directives are now allowed.
-
- * Module directives using, hiding, renaming and public can now appear in
- arbitrary order. Multiple using/hiding/renaming directives are allowed, but
- you still cannot have both using and hiding (because that doesn't make
- sense). [Issue 493]
-
-Goal and error display
-======================
-
-* The error message "Refuse to construct infinite term" has been
- removed, instead one gets unsolved meta variables. Reason: the
- error was thrown over-eagerly. [Issue 795]
-
-* If an interactive case split fails with message
-
- Since goal is solved, further case distinction is not supported;
- try `Solve constraints' instead
-
- then the associated interaction meta is assigned to a solution.
- Press C-c C-= (Show constraints) to view the solution and C-c C-s
- (Solve constraints) to apply it. [Issue 289]
-
-Type checking
-=============
-
-* [ issue 376 ] Implemented expansion of bound record variables during meta assignment.
- Now Agda can solve for metas X that are applied to projected variables, e.g.:
-
- X (fst z) (snd z) = z
-
- X (fst z) = fst z
-
- Technically, this is realized by substituting (x , y) for z with fresh
- bound variables x and y. Here the full code for the examples:
-
- record Sigma (A : Set)(B : A -> Set) : Set where
- constructor _,_
- field
- fst : A
- snd : B fst
- open Sigma
-
- test : (A : Set) (B : A -> Set) ->
- let X : (x : A) (y : B x) -> Sigma A B
- X = _
- in (z : Sigma A B) -> X (fst z) (snd z) ≡ z
- test A B z = refl
-
- test' : (A : Set) (B : A -> Set) ->
- let X : A -> A
- X = _
- in (z : Sigma A B) -> X (fst z) ≡ fst z
- test' A B z = refl
-
- The fresh bound variables are named fst(z) and snd(z) and can appear
- in error messages, e.g.:
-
- fail : (A : Set) (B : A -> Set) ->
- let X : A -> Sigma A B
- X = _
- in (z : Sigma A B) -> X (fst z) ≡ z
- fail A B z = refl
-
- results in error:
-
- Cannot instantiate the metavariable _7 to solution fst(z) , snd(z)
- since it contains the variable snd(z) which is not in scope of the
- metavariable or irrelevant in the metavariable but relevant in the
- solution
- when checking that the expression refl has type _7 A B (fst z) ≡ z
-
-* Dependent record types and definitions by copatterns require
- reduction with previous function clauses while checking the
- current clause. [Issue 907]
-
- For a simple example, consider
-
- test : ∀ {A} → Σ Nat λ n → Vec A n
- proj₁ test = zero
- proj₂ test = []
-
- For the second clause, the lhs and rhs are typed as
-
- proj₂ test : Vec A (proj₁ test)
- [] : Vec A zero
-
- In order for these types to match, we have to reduce the lhs type
- with the first function clause.
-
- Note that termination checking comes after type checking, so be
- careful to avoid non-termination! Otherwise, the type checker
- might get into an infinite loop.
-
-* The implementation of the primitive primTrustMe has changed.
- It now only reduces to REFL if the two arguments x and y have
- the same computational normal form. Before, it reduced when
- x and y were definitionally equal, which included type-directed
- equality laws such as eta-equality. Yet because reduction is
- untyped, calling conversion from reduction lead to Agda crashes
- [Issue 882].
-
- The amended description of primTrustMe is (cf. release notes for 2.2.6):
-
- primTrustMe : {A : Set} {x y : A} → x ≡ y
-
- Here _≡_ is the builtin equality (see BUILTIN hooks for equality,
- above).
-
- If x and y have the same computational normal form, then
- primTrustMe {x = x} {y = y} reduces to refl.
-
- A note on primTrustMe's runtime behavior:
- The MAlonzo compiler replaces all uses of primTrustMe with the
- REFL builtin, without any check for definitional equality. Incorrect
- uses of primTrustMe can potentially lead to segfaults or similar
- problems of the compiled code.
-
-* Implicit patterns of record type are now only eta-expanded if there
- is a record constructor. [Issues 473, 635]
-
- data D : Set where
- d : D
-
- data P : D → Set where
- p : P d
-
- record Rc : Set where
- constructor c
- field f : D
-
- works : {r : Rc} → P (Rc.f r) → Set
- works p = D
-
- This works since the implicit pattern {r} is eta-expanded to
- {c x} which allows the type of p to reduce to P x and x to be
- unified with d. The corresponding explicit version is:
-
- works' : (r : Rc) → P (Rc.f r) → Set
- works' (c .d) p = D
-
- However, if the record constructor is removed, the same example will
- fail:
-
- record R : Set where
- field f : D
-
- fails : {r : R} → P (R.f r) → Set
- fails p = D
-
- -- d != R.f r of type D
- -- when checking that the pattern p has type P (R.f r)
-
- The error is justified since there is no pattern we could write down
- for r. It would have to look like
-
- record { f = .d }
-
- but anonymous record patterns are not part of the language.
-
-* Absurd lambdas at different source locations are no longer
- different. [Issue 857]
- In particular, the following code type-checks now:
-
- absurd-equality : _≡_ {A = ⊥ → ⊥} (λ()) λ()
- absurd-equality = refl
-
- Which is a good thing!
-
-* Printing of named implicit function types.
-
- When printing terms in a context with bound variables Agda renames new
- bindings to avoid clashes with the previously bound names. For instance, if A
- is in scope, the type (A : Set) → A is printed as (A₁ : Set) → A₁. However,
- for implicit function types the name of the binding matters, since it can be
- used when giving implicit arguments.
-
- For this situation, the following new syntax has been introduced:
- {x = y : A} → B is an implicit function type whose bound variable (in scope
- in B) is y, but where the name of the argument is x for the purposes of
- giving it explicitly. For instance, with A in scope, the type {A : Set} → A
- is now printed as {A = A₁ : Set} → A₁.
-
- This syntax is only used when printing and is currently not being parsed.
-
-* Changed the semantics of --without-K. [Issue 712, Issue 865, Issue 1025]
-
- New specification of --without-K:
-
- When --without-K is enabled, the unification of indices for pattern matching
- is restricted in two ways:
-
- 1. Reflexive equations of the form x == x are no longer solved, instead Agda
- gives an error when such an equation is encountered.
-
- 2. When unifying two same-headed constructor forms 'c us' and 'c vs' of type
- 'D pars ixs', the datatype indices ixs (but not the parameters) have to
- be *self-unifiable*, i.e. unification of ixs with itself should succeed
- positively. This is a nontrivial requirement because of point 1.
-
- Examples:
-
- * The J rule is accepted.
-
- J : {A : Set} (P : {x y : A} → x ≡ y → Set) →
- (∀ x → P (refl x)) →
- ∀ {x y} (x≡y : x ≡ y) → P x≡y
- J P p (refl x) = p x
-
- This definition is accepted since unification of x with y doesn't require
- deletion or injectivity.
-
- * The K rule is rejected.
-
- K : {A : Set} (P : {x : A} → x ≡ x → Set) →
- (∀ x → P (refl {x = x})) →
- ∀ {x} (x≡x : x ≡ x) → P x≡x
- K P p refl = p _
-
- Definition is rejected with the following error:
-
- Cannot eliminate reflexive equation x = x of type A because K has
- been disabled.
- when checking that the pattern refl has type x ≡ x
-
- * Symmetry of the new criterion.
-
- test₁ : {k l m : ℕ} → k + l ≡ m → ℕ
- test₁ refl = zero
-
- test₂ : {k l m : ℕ} → k ≡ l + m → ℕ
- test₂ refl = zero
-
- Both versions are now accepted (previously only the first one was).
-
- * Handling of parameters.
-
- cons-injective : {A : Set} (x y : A) → (x ∷ []) ≡ (y ∷ []) → x ≡ y
- cons-injective x .x refl = refl
-
- Parameters are not unified, so they are ignored by the new criterion.
-
- * A larger example: antisymmetry of ≤.
-
- data _≤_ : ℕ → ℕ → Set where
- lz : (n : ℕ) → zero ≤ n
- ls : (m n : ℕ) → m ≤ n → suc m ≤ suc n
-
- ≤-antisym : (m n : ℕ) → m ≤ n → n ≤ m → m ≡ n
- ≤-antisym .zero .zero (lz .zero) (lz .zero) = refl
- ≤-antisym .(suc m) .(suc n) (ls m n p) (ls .n .m q) =
- cong suc (≤-antisym m n p q)
-
- * [ Issue 1025 ]
-
- postulate mySpace : Set
- postulate myPoint : mySpace
-
- data Foo : myPoint ≡ myPoint → Set where
- foo : Foo refl
-
- test : (i : foo ≡ foo) → i ≡ refl
- test refl = {!!}
-
- When applying injectivity to the equation "foo ≡ foo" of type "Foo refl",
- it is checked that the index refl of type "myPoint ≡ myPoint" is
- self-unifiable. The equation "refl ≡ refl" again requires injectivity, so
- now the index myPoint is checked for self-unifiability, hence the error:
-
- Cannot eliminate reflexive equation myPoint = myPoint of type
- mySpace because K has been disabled.
- when checking that the pattern refl has type foo ≡ foo
-
-Termination checking
-====================
-
-* A buggy facility coined "matrix-shaped orders" that supported
- uncurried functions (which take tuples of arguments instead of one
- argument after another) has been removed from the termination
- checker. [Issue 787]
-
-* Definitions which fail the termination checker are not unfolded any
- longer to avoid loops or stack overflows in Agda. However, the
- termination checker for a mutual block is only invoked after
- type-checking, so there can still be loops if you define a
- non-terminating function. But termination checking now happens
- before the other supplementary checks: positivity, polarity,
- injectivity and projection-likeness.
- Note that with the pragma {-# NO_TERMINATION_CHECK #-} you can make
- Agda treat any function as terminating.
-
-* Termination checking of functions defined by 'with' has been improved.
-
- Cases which previously required --termination-depth
- to pass the termination checker (due to use of 'with') no longer
- need the flag. For example
-
- merge : List A → List A → List A
- merge [] ys = ys
- merge xs [] = xs
- merge (x ∷ xs) (y ∷ ys) with x ≤ y
- merge (x ∷ xs) (y ∷ ys) | false = y ∷ merge (x ∷ xs) ys
- merge (x ∷ xs) (y ∷ ys) | true = x ∷ merge xs (y ∷ ys)
-
- This failed to termination check previously, since the 'with' expands to an
- auxiliary function merge-aux:
-
- merge-aux x y xs ys false = y ∷ merge (x ∷ xs) ys
- merge-aux x y xs ys true = x ∷ merge xs (y ∷ ys)
-
- This function makes a call to merge in which the size of one of the arguments
- is increasing. To make this pass the termination checker now inlines the
- definition of merge-aux before checking, thus effectively termination
- checking the original source program.
-
- As a result of this transformation doing 'with' on a variable no longer
- preserves termination. For instance, this does not termination check:
-
- bad : Nat → Nat
- bad n with n
- ... | zero = zero
- ... | suc m = bad m
-
-* The performance of the termination checker has been improved. For
- higher --termination-depth the improvement is significant.
- While the default --termination-depth is still 1, checking with
- higher --termination-depth should now be feasible.
-
-Compiler backends
-=================
-
-* The MAlonzo compiler backend now has support for compiling modules
- that are not full programs (i.e. don't have a main function). The
- goal is that you can write part of a program in Agda and the rest in
- Haskell, and invoke the Agda functions from the Haskell code. The
- following features were added for this reason:
-
- * A new command-line option --compile-no-main: the command
-
- agda --compile-no-main Test.agda
-
- will compile Test.agda and all its dependencies to Haskell and
- compile the resulting Haskell files with --make, but (unlike
- --compile) not tell GHC to treat Test.hs as the main module. This
- type of compilation can be invoked from emacs by customizing the
- agda2-backend variable to value MAlonzoNoMain and then calling
- "C-c C-x C-c" as before.
-
- * A new pragma COMPILED_EXPORT was added as part of the MAlonzo FFI.
- If we have an Agda file containing the following:
-
- module A.B where
-
- test : SomeType
- test = someImplementation
-
- {-# COMPILED_EXPORT test someHaskellId #-}
-
- then test will be compiled to a Haskell function called
- someHaskellId in module MAlonzo.Code.A.B that can be invoked from
- other Haskell code. Its type will be translated according to the
- normal MAlonzo rules.
-
-Tools
-=====
-
-Emacs mode
-----------
-
-* A new goal command "Helper Function Type" (C-c C-h) has been added.
-
- If you write an application of an undefined function in a goal, the Helper
- Function Type command will print the type that the function needs to have in
- order for it to fit the goal. The type is also added to the Emacs kill-ring
- and can be pasted into the buffer using C-y.
-
- The application must be of the form "f args" where f is the name of the
- helper function you want to create. The arguments can use all the normal
- features like named implicits or instance arguments.
-
- Example:
-
- Here's a start on a naive reverse on vectors:
-
- reverse : ∀ {A n} → Vec A n → Vec A n
- reverse [] = []
- reverse (x ∷ xs) = {!snoc (reverse xs) x!}
-
- Calling C-c C-h in the goal prints
-
- snoc : ∀ {A} {n} → Vec A n → A → Vec A (suc n)
-
-* A new command "Explain why a particular name is in scope" (C-c C-w) has been
- added. [Issue207]
-
- This command can be called from a goal or from the top-level and will as the
- name suggests explain why a particular name is in scope.
-
- For each definition or module that the given name can refer to a trace is
- printed of all open statements and module applications leading back to the
- original definition of the name.
-
- For example, given
-
- module A (X : Set₁) where
- data Foo : Set where
- mkFoo : Foo
- module B (Y : Set₁) where
- open A Y public
- module C = B Set
- open C
-
- Calling C-c C-w on mkFoo at the top-level prints
-
- mkFoo is in scope as
- * a constructor Issue207.C._.Foo.mkFoo brought into scope by
- - the opening of C at Issue207.agda:13,6-7
- - the application of B at Issue207.agda:11,12-13
- - the application of A at Issue207.agda:9,8-9
- - its definition at Issue207.agda:6,5-10
-
- This command is useful if Agda complains about an ambiguous name and you need
- to figure out how to hide the undesired interpretations.
-
-* Improvements to the "make case" command (C-c C-c)
-
- - One can now also split on hidden variables, using the name
- (starting with .) with which they are printed.
- Use C-c C-, to see all variables in context.
-
- - Concerning the printing of generated clauses:
-
- * Uses named implicit arguments to improve readability.
-
- * Picks explicit occurrences over implicit ones when there is a choice of
- binding site for a variable.
-
- * Avoids binding variables in implicit positions by replacing dot patterns
- that uses them by wildcards (._).
-
-* Key bindings for lots of "mathematical" characters (examples: 𝐴𝑨𝒜𝓐𝔄)
- have been added to the Agda input method.
- Example: type \MiA\MIA\McA\MCA\MfA to get 𝐴𝑨𝒜𝓐𝔄.
-
- Note: \McB does not exist in unicode (as well as others in that style),
- but the \MC (bold) alphabet is complete.
-
-* Key bindings for "blackboard bold" B (𝔹) and 0-9 (𝟘-𝟡) have been added
- to the Agda input method (\bb and \b[0-9]).
-
-* Key bindings for controlling simplification/normalisation:
-
- [TODO: Simplification should be explained somewhere.]
-
- Commands like "Goal type and context" (C-c C-,) could previously be
- invoked in two ways. By default the output was normalised, but if a
- prefix argument was used (for instance via C-u C-c C-,), then no
- explicit normalisation was performed. Now there are three options:
-
- * By default (C-c C-,) the output is simplified.
-
- * If C-u is used exactly once (C-u C-c C-,), then the result is
- neither (explicitly) normalised nor simplified.
-
- * If C-u is used twice (C-u C-u C-c C-,), then the result is
- normalised.
-
- [TODO: As part of the release of Agda 2.3.4 the key binding page on
- the wiki should be updated.]
-
-LaTeX-backend
--------------
-
-* Two new color scheme options were added to agda.sty:
-
- \usepackage[bw]{agda}, which highlights in black and white;
- \usepackage[conor]{agda}, which highlights using Conor's colors.
-
- The default (no options passed) is to use the standard colors.
-
-* If agda.sty cannot be found by the latex environment, it is now
- copied into the latex output directory ('latex' by default) instead
- of the working directory. This means that the commands needed to
- produce a PDF now is
-
- agda --latex -i . <file>.lagda
- cd latex
- pdflatex <file>.tex
-
-* The LaTeX-backend has been made more tool agnostic, in particular
- XeLaTeX and LuaLaTeX should now work. Here is a small example
- (test/LaTeXAndHTML/succeed/UnicodeInput.lagda):
-
- \documentclass{article}
- \usepackage{agda}
- \begin{document}
-
- \begin{code}
- data αβγδεζθικλμνξρστυφχψω : Set₁ where
-
- postulate
- →⇒⇛⇉⇄↦⇨↠⇀⇁ : Set
- \end{code}
-
- \[
- ∀X [ ∅ ∉ X ⇒ ∃f:X ⟶ ⋃ X\ ∀A ∈ X (f(A) ∈ A) ]
- \]
- \end{document}
-
- Compiled as follows, it should produce a nice looking PDF (tested with
- TeX Live 2012):
-
- agda --latex <file>.lagda
- cd latex
- xelatex <file>.tex (or lualatex <file>.tex)
-
- If symbols are missing or xelatex/lualatex complains about the font
- missing, try setting a different font using:
-
- \setmathfont{<math-font>}
-
- Use the fc-list tool to list available fonts.
-
-* Add experimental support for hyperlinks to identifiers
-
- If the hyperref latex package is loaded before the agda package and
- the links option is passed to the agda package, then the agda package
- provides a function called \AgdaTarget. Identifiers which have been
- declared targets, by the user, will become clickable hyperlinks in the
- rest of the document. Here is a small example
- (test/LaTeXAndHTML/succeed/Links.lagda):
-
- \documentclass{article}
- \usepackage{hyperref}
- \usepackage[links]{agda}
- \begin{document}
-
- \AgdaTarget{ℕ}
- \AgdaTarget{zero}
- \begin{code}
- data ℕ : Set where
- zero : ℕ
- suc : ℕ → ℕ
- \end{code}
-
- See next page for how to define \AgdaFunction{two} (doesn't turn into a
- link because the target hasn't been defined yet). We could do it
- manually though; \hyperlink{two}{\AgdaDatatype{two}}.
-
- \newpage
-
- \AgdaTarget{two}
- \hypertarget{two}{}
- \begin{code}
- two : ℕ
- two = suc (suc zero)
- \end{code}
-
- \AgdaInductiveConstructor{zero} is of type
- \AgdaDatatype{ℕ}. \AgdaInductiveConstructor{suc} has not been defined to
- be a target so it doesn't turn into a link.
-
- \newpage
-
- Now that the target for \AgdaFunction{two} has been defined the link
- works automatically.
-
- \begin{code}
- data Bool : Set where
- true false : Bool
- \end{code}
-
- The AgdaTarget command takes a list as input, enabling several
- targets to be specified as follows:
-
- \AgdaTarget{if, then, else, if\_then\_else\_}
- \begin{code}
- if_then_else_ : {A : Set} → Bool → A → A → A
- if true then t else f = t
- if false then t else f = f
- \end{code}
-
- \newpage
-
- Mixfix identifier need their underscores escaped:
- \AgdaFunction{if\_then\_else\_}.
-
- \end{document}
-
- The boarders around the links can be suppressed using hyperref's
- hidelinks option:
-
- \usepackage[hidelinks]{hyperref}
-
- Note that the current approach to links does not keep track of scoping
- or types, and hence overloaded names might create links which point to
- the wrong place. Therefore it is recommended to not overload names
- when using the links option at the moment, this might get fixed in the
- future.
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.3.2.2
-------------------------------------------------------------------------
-
-Important changes since 2.3.2.1:
-
-* Fixed a bug that sometimes made it tricky to use the Emacs mode on
- Windows [issue 757].
-
-* Made Agda build with newer versions of some libraries.
-
-* Fixed a bug that caused ambiguous parse error messages [issue 147].
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.3.2.1
-------------------------------------------------------------------------
-
-Important changes since 2.3.2:
-
-Installation
-============
-
-* Made it possible to compile Agda with more recent versions of
- hashable, QuickCheck and Win32.
-
-* Excluded mtl-2.1.
-
-Type checking
-=============
-
-* Fixed bug in the termination checker (issue 754).
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.3.2
-------------------------------------------------------------------------
-
-Important changes since 2.3.0:
-
-Installation
-============
-
-* The Agda-executable package has been removed.
-
- The executable is now provided as part of the Agda package.
-
-* The Emacs mode no longer depends on haskell-mode or GHCi.
-
-* Compilation of Emacs mode Lisp files.
-
- You can now compile the Emacs mode Lisp files by running "agda-mode
- compile". This command is run by "make install".
-
- Compilation can, in some cases, give a noticeable speedup.
-
- WARNING: If you reinstall the Agda mode without recompiling the
- Emacs Lisp files, then Emacs may continue using the old, compiled
- files.
-
-Pragmas and options
-===================
-
-* The --without-K check now reconstructs constructor parameters.
-
- New specification of --without-K:
-
- If the flag is activated, then Agda only accepts certain
- case-splits. If the type of the variable to be split is D pars ixs,
- where D is a data (or record) type, pars stands for the parameters,
- and ixs the indices, then the following requirements must be
- satisfied:
-
- * The indices ixs must be applications of constructors (or literals)
- to distinct variables. Constructors are usually not applied to
- parameters, but for the purposes of this check constructor
- parameters are treated as other arguments.
-
- * These distinct variables must not be free in pars.
-
-* Irrelevant arguments are printed as _ by default now. To turn on
- printing of irrelevant arguments, use option
-
- --show-irrelevant
-
-* New: Pragma NO_TERMINATION_CHECK to switch off termination checker
- for individual function definitions and mutual blocks.
-
- The pragma must precede a function definition or a mutual block.
- Examples (see test/Succeed/NoTerminationCheck.agda):
-
- 1. Skipping a single definition: before type signature.
-
- {-# NO_TERMINATION_CHECK #-}
- a : A
- a = a
-
- 2. Skipping a single definition: before first clause.
-
- b : A
- {-# NO_TERMINATION_CHECK #-}
- b = b
-
- 3. Skipping an old-style mutual block: Before 'mutual' keyword.
-
- {-# NO_TERMINATION_CHECK #-}
- mutual
- c : A
- c = d
-
- d : A
- d = c
-
- 4. Skipping a new-style mutual block: Anywhere before a type
- signature or first function clause in the block
-
- i : A
- j : A
-
- i = j
- {-# NO_TERMINATION_CHECK #-}
- j = i
-
- The pragma cannot be used in --safe mode.
-
-Language
-========
-
-* Let binding record patterns
-
- record _×_ (A B : Set) : Set where
- constructor _,_
- field
- fst : A
- snd : B
- open _×_
-
- let (x , (y , z)) = t
- in u
-
- will now be interpreted as
-
- let x = fst t
- y = fst (snd t)
- z = snd (snd t)
- in u
-
- Note that the type of t needs to be inferable. If you need to provide
- a type signature, you can write the following:
-
- let a : ...
- a = t
- (x , (y , z)) = a
- in u
-
-* Pattern synonyms
-
- A pattern synonym is a declaration that can be used on the left hand
- side (when pattern matching) as well as the right hand side (in
- expressions). For example:
-
- pattern z = zero
- pattern ss x = suc (suc x)
-
- f : ℕ -> ℕ
- f z = z
- f (suc z) = ss z
- f (ss n) = n
-
- Pattern synonyms are implemented by substitution on the abstract
- syntax, so definitions are scope-checked but not type-checked. They
- are particularly useful for universe constructions.
-
-* Qualified mixfix operators
-
- It is now possible to use a qualified mixfix operator by qualifying the first
- part of the name. For instance
-
- import Data.Nat as Nat
- import Data.Bool as Bool
-
- two = Bool.if true then 1 Nat.+ 1 else 0
-
-* Sections [Issue 735]. Agda now parses anonymous modules as sections:
-
- module _ {a} (A : Set a) where
-
- data List : Set a where
- [] : List
- _∷_ : (x : A) (xs : List) → List
-
- module _ {a} {A : Set a} where
-
- _++_ : List A → List A → List A
- [] ++ ys = ys
- (x ∷ xs) ++ ys = x ∷ (xs ++ ys)
-
- test : List Nat
- test = (5 ∷ []) ++ (3 ∷ [])
-
- In general, now the syntax
-
- module _ parameters where
- declarations
-
- is accepted and has the same effect as
-
- private
- module M parameters where
- declarations
- open M public
-
- for a fresh name M.
-
-* Instantiating a module in an open import statement [Issue 481]. Now accepted:
-
- open import Path.Module args [using/hiding/renaming (...)]
-
- This only brings the imported identifiers from Path.Module into scope,
- not the module itself! Consequently, the following is pointless, and raises
- an error:
-
- import Path.Module args [using/hiding/renaming (...)]
-
- You can give a private name M to the instantiated module via
-
- import Path.Module args as M [using/hiding/renaming (...)]
- open import Path.Module args as M [using/hiding/renaming (...)]
-
- Try to avoid 'as' as part of the arguments. 'as' is not a keyword;
- the following can be legal, although slightly obfuscated Agda code:
-
- open import as as as as as as
-
-* Implicit module parameters can be given by name. E.g.
-
- open M {namedArg = bla}
-
- This feature has been introduced in Agda 2.3.0 already.
-
-* Multiple type signatures sharing a same type can now be written as a single
- type signature.
-
- one two : ℕ
- one = suc zero
- two = suc one
-
-Goal and error display
-======================
-
-* Meta-variables that were introduced by hidden argument `arg' are now
- printed as _arg_number instead of just _number. [Issue 526]
-
-* Agda expands identifiers in anonymous modules when printing.
- Should make some goals nicer to read. [Issue 721]
-
-* When a module identifier is ambiguous, Agda tells you if one
- of them is a data type module. [Issues 318, 705]
-
-Type checking
-=============
-
-* Improved coverage checker. The coverage checker splits on
- arguments that have constructor or literal pattern, committing
- to the left-most split that makes progress.
- Consider the lookup function for vectors:
-
- data Fin : Nat → Set where
- zero : {n : Nat} → Fin (suc n)
- suc : {n : Nat} → Fin n → Fin (suc n)
-
- data Vec (A : Set) : Nat → Set where
- [] : Vec A zero
- _∷_ : {n : Nat} → A → Vec A n → Vec A (suc n)
-
- _!!_ : {A : Set}{n : Nat} → Vec A n → Fin n → A
- (x ∷ xs) !! zero = x
- (x ∷ xs) !! suc i = xs !! i
-
- In Agda up to 2.3.0, this definition is rejected unless we add
- an absurd clause
-
- [] !! ()
-
- This is because the coverage checker committed on splitting
- on the vector argument, even though this inevitably lead to
- failed coverage, because a case for the empty vector [] is missing.
-
- The improvement to the coverage checker consists on committing
- only on splits that have a chance of covering, since all possible
- constructor patterns are present. Thus, Agda will now split
- first on the Fin argument, since cases for both zero and suc are
- present. Then, it can split on the Vec argument, since the
- empty vector is already ruled out by instantiating n to a suc _.
-
-* Instance arguments resolution will now consider candidates which
- still expect hidden arguments. For example:
-
- record Eq (A : Set) : Set where
- field eq : A → A → Bool
-
- open Eq {{...}}
-
- eqFin : {n : ℕ} → Eq (Fin n)
- eqFin = record { eq = primEqFin }
-
- testFin : Bool
- testFin = eq fin1 fin2
-
- The type-checker will now resolve the instance argument of the eq
- function to eqFin {_}. This is only done for hidden arguments, not
- instance arguments, so that the instance search stays non-recursive.
-
-* Constraint solving: Upgraded Miller patterns to record patterns. [Issue 456]
-
- Agda now solves meta-variables that are applied to record patterns.
- A typical (but here, artificial) case is:
-
- record Sigma (A : Set)(B : A -> Set) : Set where
- constructor _,_
- field
- fst : A
- snd : B fst
-
- test : (A : Set)(B : A -> Set) ->
- let X : Sigma A B -> Sigma A B
- X = _
- in (x : A)(y : B x) -> X (x , y) ≡ (x , y)
- test A B x y = refl
-
- This yields a constraint of the form
-
- _X A B (x , y) := t[x,y]
-
- (with t[x,y] = (x, y)) which is not a Miller pattern.
- However, Agda now solves this as
-
- _X A B z := t[fst z,snd z].
-
-* Changed: solving recursive constraints. [Issue 585]
-
- Until 2.3.0, Agda sometimes inferred values that did not pass the
- termination checker later, or would even make Agda loop. To prevent this,
- the occurs check now also looks into the definitions of the current mutual
- block, to avoid constructing recursive solutions. As a consequence, also
- terminating recursive solutions are no longer found automatically.
-
- This effects a programming pattern where the recursively computed
- type of a recursive function is left to Agda to solve.
-
- mutual
-
- T : D -> Set
- T pattern1 = _
- T pattern2 = _
-
- f : (d : D) -> T d
- f pattern1 = rhs1
- f pattern2 = rhs2
-
- This might no longer work from now on.
- See examples test/Fail/Issue585*.agda
-
-* Less eager introduction of implicit parameters. [Issue 679]
-
- Until Agda 2.3.0, trailing hidden parameters were introduced eagerly
- on the left hand side of a definition. For instance, one could not
- write
-
- test : {A : Set} -> Set
- test = \ {A} -> A
-
- because internally, the hidden argument {A : Set} was added to the
- left-hand side, yielding
-
- test {_} = \ {A} -> A
-
- which raised a type error. Now, Agda only introduces the trailing
- implicit parameters it has to, in order to maintain uniform function
- arity. For instance, in
-
- test : Bool -> {A B C : Set} -> Set
- test true {A} = A
- test false {B = B} = B
-
- Agda will introduce parameters A and B in all clauses, but not C,
- resulting in
-
- test : Bool -> {A B C : Set} -> Set
- test true {A} {_} = A
- test false {_} {B = B} = B
-
- Note that for checking where-clauses, still all hidden trailing
- parameters are in scope. For instance:
-
- id : {i : Level}{A : Set i} -> A -> A
- id = myId
- where myId : forall {A} -> A -> A
- myId x = x
-
- To be able to fill in the meta variable _1 in
-
- myId : {A : Set _1} -> A -> A
-
- the hidden parameter {i : Level} needs to be in scope.
-
- As a result of this more lazy introduction of implicit parameters,
- the following code now passes.
-
- data Unit : Set where
- unit : Unit
-
- T : Unit → Set
- T unit = {u : Unit} → Unit
-
- test : (u : Unit) → T u
- test unit with unit
- ... | _ = λ {v} → v
-
- Before, Agda would eagerly introduce the hidden parameter {v} as
- unnamed left-hand side parameter, leaving no way to refer to it.
-
- The related issue 655 has also been addressed. It is now possible
- to make `synonym' definitions
-
- name = expression
-
- even when the type of expression begins with a hidden quantifier.
- Simple example:
-
- id2 = id
-
- That resulted in unsolved metas until 2.3.0.
-
-* Agda detects unused arguments and ignores them during equality
- checking. [Issue 691, solves also issue 44.]
-
- Agda's polarity checker now assigns 'Nonvariant' to arguments
- that are not actually used (except for absurd matches). If
- f's first argument is Nonvariant, then f x is definitionally equal
- to f y regardless of x and y. It is similar to irrelevance, but
- does not require user annotation.
-
- For instance, unused module parameters do no longer get in the way:
-
- module M (x : Bool) where
-
- not : Bool → Bool
- not true = false
- not false = true
-
- open M true
- open M false renaming (not to not′)
-
- test : (y : Bool) → not y ≡ not′ y
- test y = refl
-
- Matching against record or absurd patterns does not count as `use',
- so we get some form of proof irrelevance:
-
- data ⊥ : Set where
- record ⊤ : Set where
- constructor trivial
-
- data Bool : Set where
- true false : Bool
-
- True : Bool → Set
- True true = ⊤
- True false = ⊥
-
- fun : (b : Bool) → True b → Bool
- fun true trivial = true
- fun false ()
-
- test : (b : Bool) → (x y : True b) → fun b x ≡ fun b y
- test b x y = refl
-
- More examples in test/Succeed/NonvariantPolarity.agda.
-
- Phantom arguments: Parameters of record and data types are considered
- `used' even if they are not actually used. Consider:
-
- False : Nat → Set
- False zero = ⊥
- False (suc n) = False n
-
- module Invariant where
- record Bla (n : Nat)(p : False n) : Set where
-
- module Nonvariant where
- Bla : (n : Nat) → False n → Set
- Bla n p = ⊤
-
- Even though record `Bla' does not use its parameters n and p, they
- are considered as used, allowing "phantom type" techniques.
-
- In contrast, the arguments of function `Bla' are recognized as unused.
- The following code type-checks if we open Invariant but leaves unsolved
- metas if we open Nonvariant.
-
- drop-suc : {n : Nat}{p : False n} → Bla (suc n) p → Bla n p
- drop-suc _ = _
-
- bla : (n : Nat) → {p : False n} → Bla n p → ⊥
- bla zero {()} b
- bla (suc n) b = bla n (drop-suc b)
-
- If `Bla' is considered invariant, the hidden argument in the recursive
- call can be inferred to be `p'. If it is considered non-variant, then
- `Bla n X = Bla n p' does not entail `X = p' and the hidden argument
- remains unsolved. Since `bla' does not actually use its hidden argument,
- its value is not important and it could be searched for.
- Unfortunately, polarity analysis of `bla' happens only after type
- checking, thus, the information that `bla' is non-variant in `p' is
- not available yet when meta-variables are solved.
- (See test/Fail/BrokenInferenceDueToNonvariantPolarity.agda)
-
-* Agda now expands simple definitions (one clause, terminating)
- to check whether a function is constructor headed. [Issue 747]
- For instance, the following now also works:
-
- MyPair : Set -> Set -> Set
- MyPair A B = Pair A B
-
- Vec : Set -> Nat -> Set
- Vec A zero = Unit
- Vec A (suc n) = MyPair A (Vec A n)
-
- Here, Unit and Pair are data or record types.
-
-Compiler backends
-=================
-
-* -Werror is now overridable.
-
- To enable compilation of Haskell modules containing warnings, the
- -Werror flag for the MAlonzo backend has been made overridable. If,
- for example, --ghc-flag=-Wwarn is passed when compiling, one can get
- away with things like:
-
- data PartialBool : Set where
- true : PartialBool
-
- {-# COMPILED_DATA PartialBool Bool True #-}
-
- The default behavior remains as it used to be and rejects the above
- program.
-
-Tools
-=====
-
-Emacs mode
-----------
-
-* Asynchronous Emacs mode.
-
- One can now use Emacs while a buffer is type-checked. If the buffer
- is edited while the type-checker runs, then syntax highlighting will
- not be updated when type-checking is complete.
-
-* Interactive syntax highlighting.
-
- The syntax highlighting is updated while a buffer is type-checked:
-
- • At first the buffer is highlighted in a somewhat crude way
- (without go-to-definition information for overloaded
- constructors).
-
- • If the highlighting level is "interactive", then the piece of code
- that is currently being type-checked is highlighted as such. (The
- default is "non-interactive".)
-
- • When a mutual block has been type-checked it is highlighted
- properly (this highlighting includes warnings for potential
- non-termination).
-
- The highlighting level can be controlled via the new configuration
- variable agda2-highlight-level.
-
-* Multiple case-splits can now be performed in one go.
-
- Consider the following example:
-
- _==_ : Bool → Bool → Bool
- b₁ == b₂ = {!!}
-
- If you split on "b₁ b₂", then you get the following code:
-
- _==_ : Bool → Bool → Bool
- true == true = {!!}
- true == false = {!!}
- false == true = {!!}
- false == false = {!!}
-
- The order of the variables matters. Consider the following code:
-
- lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A
- lookup xs i = {!!}
-
- If you split on "xs i", then you get the following code:
-
- lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A
- lookup [] ()
- lookup (x ∷ xs) zero = {!!}
- lookup (x ∷ xs) (suc i) = {!!}
-
- However, if you split on "i xs", then you get the following code
- instead:
-
- lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A
- lookup (x ∷ xs) zero = ?
- lookup (x ∷ xs) (suc i) = ?
-
- This code is rejected by Agda 2.3.0, but accepted by 2.3.2 thanks
- to improved coverage checking (see above).
-
-* The Emacs mode now presents information about which module is
- currently being type-checked.
-
-* New global menu entry: Information about the character at point.
-
- If this entry is selected, then information about the character at
- point is displayed, including (in many cases) information about how
- to type the character.
-
-* Commenting/uncommenting the rest of the buffer.
-
- One can now comment or uncomment the rest of the buffer by typing
- C-c C-x M-; or by selecting the menu entry "Comment/uncomment the
- rest of the buffer".
-
-* The Emacs mode now uses the Agda executable instead of GHCi.
-
- The *ghci* buffer has been renamed to *agda2*.
-
- A new configuration variable has been introduced:
- agda2-program-name, the name of the Agda executable (by default
- agda).
-
- The variable agda2-ghci-options has been replaced by
- agda2-program-args: extra arguments given to the Agda executable (by
- default none).
-
- If you want to limit Agda's memory consumption you can add some
- arguments to agda2-program-args, for instance +RTS -M1.5G -RTS.
-
-* The Emacs mode no longer depends on haskell-mode.
-
- Users who have customised certain haskell-mode variables (such as
- haskell-ghci-program-args) may want to update their configuration.
-
-LaTeX-backend
--------------
-
-An experimental LaTeX-backend which does precise highlighting a la the
-HTML-backend and code alignment a la lhs2TeX has been added.
-
-Here is a sample input literate Agda file:
-
- \documentclass{article}
-
- \usepackage{agda}
-
- \begin{document}
-
- The following module declaration will be hidden in the output.
-
- \AgdaHide{
- \begin{code}
- module M where
- \end{code}
- }
-
- Two or more spaces can be used to make the backend align stuff.
-
- \begin{code}
- data ℕ : Set where
- zero : ℕ
- suc : ℕ → ℕ
-
- _+_ : ℕ → ℕ → ℕ
- zero + n = n
- suc m + n = suc (m + n)
- \end{code}
-
- \end{document}
-
-To produce an output PDF issue the following commands:
-
- agda --latex -i . <file>.lagda
- pdflatex latex/<file>.tex
-
-Only the top-most module is processed, like with lhs2tex and unlike with
-the HTML-backend. If you want to process imported modules you have to
-call agda --latex manually on each of those modules.
-
-There are still issues related to formatting, see the bug tracker for
-more information:
-
- https://code.google.com/p/agda/issues/detail?id=697
-
-The default agda.sty might therefore change in backwards-incompatible
-ways, as work proceeds in trying to resolve those problems.
-
-
-Implemented features:
-
- * Two or more spaces can be used to force alignment of things, like
- with lhs2tex. See example above.
-
- * The highlighting information produced by the type checker is used to
- generate the output. For example, the data declaration in the example
- above, produces:
-
- \AgdaKeyword{data} \AgdaDatatype{ℕ} \AgdaSymbol{:}
- \AgdaPrimitiveType{Set} \AgdaKeyword{where}
-
- These latex commands are defined in agda.sty (which is imported by
- \usepackage{agda}) and cause the highlighting.
-
- * The latex-backend checks if agda.sty is found by the latex
- environment, if it isn't a default agda.sty is copied from Agda's
- data-dir into the working directory (and thus made available to the
- latex environment).
-
- If the default agda.sty isn't satisfactory (colors, fonts, spacing,
- etc) then the user can modify it and make put it somewhere where the
- latex environment can find it. Hopefully most aspects should be
- modifiable via agda.sty rather than having to tweak the
- implementation.
-
- * --latex-dir can be used to change the default output directory.
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.3.0
-------------------------------------------------------------------------
-
-Important changes since 2.2.10:
-
-Language
-========
-
-* New more liberal syntax for mutually recursive definitions.
-
- It is no longer necessary to use the 'mutual' keyword to define
- mutually recursive functions or datatypes. Instead, it is enough to
- declare things before they are used. Instead of
-
- mutual
- f : A
- f = a[f, g]
-
- g : B[f]
- g = b[f, g]
-
- you can now write
-
- f : A
- g : B[f]
- f = a[f, g]
- g = b[f, g].
-
- With the new style you have more freedom in choosing the order in
- which things are type checked (previously type signatures were
- always checked before definitions). Furthermore you can mix
- arbitrary declarations, such as modules and postulates, with
- mutually recursive definitions.
-
- For data types and records the following new syntax is used to
- separate the declaration from the definition:
-
- -- Declaration.
- data Vec (A : Set) : Nat → Set -- Note the absence of 'where'.
-
- -- Definition.
- data Vec A where
- [] : Vec A zero
- _::_ : {n : Nat} → A → Vec A n → Vec A (suc n)
-
- -- Declaration.
- record Sigma (A : Set) (B : A → Set) : Set
-
- -- Definition.
- record Sigma A B where
- constructor _,_
- field fst : A
- snd : B fst
-
- When making separated declarations/definitions private or abstract
- you should attach the 'private' keyword to the declaration and the
- 'abstract' keyword to the definition. For instance, a private,
- abstract function can be defined as
-
- private
- f : A
- abstract
- f = e
-
- Finally it may be worth noting that the old style of mutually
- recursive definitions is still supported (it basically desugars into
- the new style).
-
-* Pattern matching lambdas.
-
- Anonymous pattern matching functions can be defined using the syntax
-
- \ { p11 .. p1n -> e1 ; ... ; pm1 .. pmn -> em }
-
- (where, as usual, \ and -> can be replaced by λ and →). Internally
- this is translated into a function definition of the following form:
-
- .extlam p11 .. p1n = e1
- ...
- .extlam pm1 .. pmn = em
-
- This means that anonymous pattern matching functions are generative.
- For instance, refl will not be accepted as an inhabitant of the type
-
- (λ { true → true ; false → false }) ≡
- (λ { true → true ; false → false }),
-
- because this is equivalent to extlam1 ≡ extlam2 for some distinct
- fresh names extlam1 and extlam2.
-
- Currently the 'where' and 'with' constructions are not allowed in
- (the top-level clauses of) anonymous pattern matching functions.
-
- Examples:
-
- and : Bool → Bool → Bool
- and = λ { true x → x ; false _ → false }
-
- xor : Bool → Bool → Bool
- xor = λ { true true → false
- ; false false → false
- ; _ _ → true
- }
-
- fst : {A : Set} {B : A → Set} → Σ A B → A
- fst = λ { (a , b) → a }
-
- snd : {A : Set} {B : A → Set} (p : Σ A B) → B (fst p)
- snd = λ { (a , b) → b }
-
-* Record update syntax.
-
- Assume that we have a record type and a corresponding value:
-
- record MyRecord : Set where
- field
- a b c : ℕ
-
- old : MyRecord
- old = record { a = 1; b = 2; c = 3 }
-
- Then we can update (some of) the record value's fields in the
- following way:
-
- new : MyRecord
- new = record old { a = 0; c = 5 }
-
- Here new normalises to record { a = 0; b = 2; c = 5 }. Any
- expression yielding a value of type MyRecord can be used instead of
- old.
-
- Record updating is not allowed to change types: the resulting value
- must have the same type as the original one, including the record
- parameters. Thus, the type of a record update can be inferred if the type
- of the original record can be inferred.
-
- The record update syntax is expanded before type checking. When the
- expression
-
- record old { upd-fields }
-
- is checked against a record type R, it is expanded to
-
- let r = old in record { new-fields },
-
- where old is required to have type R and new-fields is defined as
- follows: for each field x in R,
-
- - if x = e is contained in upd-fields then x = e is included in
- new-fields, and otherwise
- - if x is an explicit field then x = R.x r is included in
- new-fields, and
- - if x is an implicit or instance field, then it is omitted from
- new-fields.
-
- (Instance arguments are explained below.) The reason for treating
- implicit and instance fields specially is to allow code like the
- following:
-
- record R : Set where
- field
- {length} : ℕ
- vec : Vec ℕ length
- -- More fields…
-
- xs : R
- xs = record { vec = 0 ∷ 1 ∷ 2 ∷ [] }
-
- ys = record xs { vec = 0 ∷ [] }
-
- Without the special treatment the last expression would need to
- include a new binding for length (for instance "length = _").
-
-* Record patterns which do not contain data type patterns, but which
- do contain dot patterns, are no longer rejected.
-
-* When the --without-K flag is used literals are now treated as
- constructors.
-
-* Under-applied functions can now reduce.
-
- Consider the following definition:
-
- id : {A : Set} → A → A
- id x = x
-
- Previously the expression id would not reduce. This has been changed
- so that it now reduces to λ x → x. Usually this makes little
- difference, but it can be important in conjunction with 'with'. See
- issue 365 for an example.
-
-* Unused AgdaLight legacy syntax (x y : A; z v : B) for telescopes has
- been removed.
-
-Universe polymorphism
----------------------
-
-* Universe polymorphism is now enabled by default.
- Use --no-universe-polymorphism to disable it.
-
-* Universe levels are no longer defined as a data type.
-
- The basic level combinators can be introduced in the following way:
-
- postulate
- Level : Set
- zero : Level
- suc : Level → Level
- max : Level → Level → Level
-
- {-# BUILTIN LEVEL Level #-}
- {-# BUILTIN LEVELZERO zero #-}
- {-# BUILTIN LEVELSUC suc #-}
- {-# BUILTIN LEVELMAX max #-}
-
-* The BUILTIN equality is now required to be universe-polymorphic.
-
-* trustMe is now universe-polymorphic.
-
-Meta-variables and unification
-------------------------------
-
-* Unsolved meta-variables are now frozen after every mutual block.
- This means that they cannot be instantiated by subsequent code. For
- instance,
-
- one : Nat
- one = _
-
- bla : one ≡ suc zero
- bla = refl
-
- leads to an error now, whereas previously it lead to the
- instantiation of _ with "suc zero". If you want to make use of the
- old behaviour, put the two definitions in a mutual block.
-
- All meta-variables are unfrozen during interactive editing, so that
- the user can fill holes interactively. Note that type-checking of
- interactively given terms is not perfect: Agda sometimes refuses to
- load a file, even though no complaints were raised during the
- interactive construction of the file. This is because certain checks
- (for instance, positivity) are only invoked when a file is loaded.
-
-* Record types can now be inferred.
-
- If there is a unique known record type with fields matching the
- fields in a record expression, then the type of the expression will
- be inferred to be the record type applied to unknown parameters.
-
- If there is no known record type with the given fields the type
- checker will give an error instead of producing lots of unsolved
- meta-variables.
-
- Note that "known record type" refers to any record type in any
- imported module, not just types which are in scope.
-
-* The occurrence checker distinguishes rigid and strongly rigid
- occurrences [Reed, LFMTP 2009; Abel & Pientka, TLCA 2011].
-
- The completeness checker now accepts the following code:
-
- h : (n : Nat) → n ≡ suc n → Nat
- h n ()
-
- Internally this generates a constraint _n = suc _n where the
- meta-variable _n occurs strongly rigidly, i.e. on a constructor path
- from the root, in its own defining term tree. This is never
- solvable.
-
- Weakly rigid recursive occurrences may have a solution [Jason Reed's
- PhD thesis, page 106]:
-
- test : (k : Nat) →
- let X : (Nat → Nat) → Nat
- X = _
- in
- (f : Nat → Nat) → X f ≡ suc (f (X (λ x → k)))
- test k f = refl
-
- The constraint _X k f = suc (f (_X k (λ x → k))) has the solution
- _X k f = suc (f (suc k)), despite the recursive occurrence of _X.
- Here _X is not strongly rigid, because it occurs under the bound
- variable f. Previously Agda rejected this code; now it instead
- complains about an unsolved meta-variable.
-
-* Equation constraints involving the same meta-variable in the head
- now trigger pruning [Pientka, PhD, Sec. 3.1.2; Abel & Pientka, TLCA
- 2011]. Example:
-
- same : let X : A → A → A → A × A
- X = _
- in {x y z : A} → X x y y ≡ (x , y)
- × X x x y ≡ X x y y
- same = refl , refl
-
- The second equation implies that X cannot depend on its second
- argument. After pruning the first equation is linear and can be
- solved.
-
-* Instance arguments.
-
- A new type of hidden function arguments has been added: instance
- arguments. This new feature is based on influences from Scala's
- implicits and Agda's existing implicit arguments.
-
- Plain implicit arguments are marked by single braces: {…}. Instance
- arguments are instead marked by double braces: {{…}}. Example:
-
- postulate
- A : Set
- B : A → Set
- a : A
- f : {{a : A}} → B a
-
- Instead of the double braces you can use the symbols ⦃ and ⦄, but
- these symbols must in many cases be surrounded by whitespace. (If
- you are using Emacs and the Agda input method, then you can conjure
- up the symbols by typing "\{{" and "\}}", respectively.)
-
- Instance arguments behave as ordinary implicit arguments, except for
- one important aspect: resolution of arguments which are not provided
- explicitly. For instance, consider the following code:
-
- test = f
-
- Here Agda will notice that f's instance argument was not provided
- explicitly, and try to infer it. All definitions in scope at f's
- call site, as well as all variables in the context, are considered.
- If exactly one of these names has the required type (A), then the
- instance argument will be instantiated to this name.
-
- This feature can be used as an alternative to Haskell type classes.
- If we define
-
- record Eq (A : Set) : Set where
- field equal : A → A → Bool,
-
- then we can define the following projection:
-
- equal : {A : Set} {{eq : Eq A}} → A → A → Bool
- equal {{eq}} = Eq.equal eq
-
- Now consider the following expression:
-
- equal false false ∨ equal 3 4
-
- If the following Eq "instances" for Bool and ℕ are in scope, and no
- others, then the expression is accepted:
-
- eq-Bool : Eq Bool
- eq-Bool = record { equal = … }
-
- eq-ℕ : Eq ℕ
- eq-ℕ = record { equal = … }
-
- A shorthand notation is provided to avoid the need to define
- projection functions manually:
-
- module Eq-with-implicits = Eq {{...}}
-
- This notation creates a variant of Eq's record module, where the
- main Eq argument is an instance argument instead of an explicit one.
- It is equivalent to the following definition:
-
- module Eq-with-implicits {A : Set} {{eq : Eq A}} = Eq eq
-
- Note that the short-hand notation allows you to avoid naming the
- "-with-implicits" module:
-
- open Eq {{...}}
-
- Instance argument resolution is not recursive. As an example,
- consider the following "parametrised instance":
-
- eq-List : {A : Set} → Eq A → Eq (List A)
- eq-List {A} eq = record { equal = eq-List-A }
- where
- eq-List-A : List A → List A → Bool
- eq-List-A [] [] = true
- eq-List-A (a ∷ as) (b ∷ bs) = equal a b ∧ eq-List-A as bs
- eq-List-A _ _ = false
-
- Assume that the only Eq instances in scope are eq-List and eq-ℕ.
- Then the following code does not type-check:
-
- test = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])
-
- However, we can make the code work by constructing a suitable
- instance manually:
-
- test′ = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])
- where eq-List-ℕ = eq-List eq-ℕ
-
- By restricting the "instance search" to be non-recursive we avoid
- introducing a new, compile-time-only evaluation model to Agda.
-
- For more information about instance arguments, see Devriese &
- Piessens [ICFP 2011]. Some examples are also available in the
- examples/instance-arguments subdirectory of the Agda distribution.
-
-Irrelevance
------------
-
-* Dependent irrelevant function types.
-
- Some examples illustrating the syntax of dependent irrelevant
- function types:
-
- .(x y : A) → B .{x y z : A} → B
- ∀ x .y → B ∀ x .{y} {z} .v → B
-
- The declaration
-
- f : .(x : A) → B[x]
- f x = t[x]
-
- requires that x is irrelevant both in t[x] and in B[x]. This is
- possible if, for instance, B[x] = B′ x, with B′ : .A → Set.
-
- Dependent irrelevance allows us to define the eliminator for the
- Squash type:
-
- record Squash (A : Set) : Set where
- constructor squash
- field
- .proof : A
-
- elim-Squash : {A : Set} (P : Squash A → Set)
- (ih : .(a : A) → P (squash a)) →
- (a⁻ : Squash A) → P a⁻
- elim-Squash P ih (squash a) = ih a
-
- Note that this would not type-check with
- (ih : (a : A) -> P (squash a)).
-
-* Records with only irrelevant fields.
-
- The following now works:
-
- record IsEquivalence {A : Set} (_≈_ : A → A → Set) : Set where
- field
- .refl : Reflexive _≈_
- .sym : Symmetric _≈_
- .trans : Transitive _≈_
-
- record Setoid : Set₁ where
- infix 4 _≈_
- field
- Carrier : Set
- _≈_ : Carrier → Carrier → Set
- .isEquivalence : IsEquivalence _≈_
-
- open IsEquivalence isEquivalence public
-
- Previously Agda complained about the application
- IsEquivalence isEquivalence, because isEquivalence is irrelevant and
- the IsEquivalence module expected a relevant argument. Now, when
- record modules are generated for records consisting solely of
- irrelevant arguments, the record parameter is made irrelevant:
-
- module IsEquivalence {A : Set} {_≈_ : A → A → Set}
- .(r : IsEquivalence {A = A} _≈_) where
- …
-
-* Irrelevant things are no longer erased internally. This means that
- they are printed as ordinary terms, not as "_" as before.
-
-* The new flag --experimental-irrelevance enables irrelevant universe
- levels and matching on irrelevant data when only one constructor is
- available. These features are very experimental and likely to change
- or disappear.
-
-Reflection
-----------
-
-* The reflection API has been extended to mirror features like
- irrelevance, instance arguments and universe polymorphism, and to
- give (limited) access to definitions. For completeness all the
- builtins and primitives are listed below:
-
- -- Names.
-
- postulate Name : Set
-
- {-# BUILTIN QNAME Name #-}
-
- primitive
- -- Equality of names.
- primQNameEquality : Name → Name → Bool
-
- -- Is the argument visible (explicit), hidden (implicit), or an
- -- instance argument?
-
- data Visibility : Set where
- visible hidden instance : Visibility
-
- {-# BUILTIN HIDING Visibility #-}
- {-# BUILTIN VISIBLE visible #-}
- {-# BUILTIN HIDDEN hidden #-}
- {-# BUILTIN INSTANCE instance #-}
-
- -- Arguments can be relevant or irrelevant.
-
- data Relevance : Set where
- relevant irrelevant : Relevance
-
- {-# BUILTIN RELEVANCE Relevance #-}
- {-# BUILTIN RELEVANT relevant #-}
- {-# BUILTIN IRRELEVANT irrelevant #-}
-
- -- Arguments.
-
- data Arg A : Set where
- arg : (v : Visibility) (r : Relevance) (x : A) → Arg A
-
- {-# BUILTIN ARG Arg #-}
- {-# BUILTIN ARGARG arg #-}
-
- -- Terms.
-
- mutual
- data Term : Set where
- -- Variable applied to arguments.
- var : (x : ℕ) (args : List (Arg Term)) → Term
- -- Constructor applied to arguments.
- con : (c : Name) (args : List (Arg Term)) → Term
- -- Identifier applied to arguments.
- def : (f : Name) (args : List (Arg Term)) → Term
- -- Different kinds of λ-abstraction.
- lam : (v : Visibility) (t : Term) → Term
- -- Pi-type.
- pi : (t₁ : Arg Type) (t₂ : Type) → Term
- -- A sort.
- sort : Sort → Term
- -- Anything else.
- unknown : Term
-
- data Type : Set where
- el : (s : Sort) (t : Term) → Type
-
- data Sort : Set where
- -- A Set of a given (possibly neutral) level.
- set : (t : Term) → Sort
- -- A Set of a given concrete level.
- lit : (n : ℕ) → Sort
- -- Anything else.
- unknown : Sort
-
- {-# BUILTIN AGDASORT Sort #-}
- {-# BUILTIN AGDATYPE Type #-}
- {-# BUILTIN AGDATERM Term #-}
- {-# BUILTIN AGDATERMVAR var #-}
- {-# BUILTIN AGDATERMCON con #-}
- {-# BUILTIN AGDATERMDEF def #-}
- {-# BUILTIN AGDATERMLAM lam #-}
- {-# BUILTIN AGDATERMPI pi #-}
- {-# BUILTIN AGDATERMSORT sort #-}
- {-# BUILTIN AGDATERMUNSUPPORTED unknown #-}
- {-# BUILTIN AGDATYPEEL el #-}
- {-# BUILTIN AGDASORTSET set #-}
- {-# BUILTIN AGDASORTLIT lit #-}
- {-# BUILTIN AGDASORTUNSUPPORTED unknown #-}
-
- postulate
- -- Function definition.
- Function : Set
- -- Data type definition.
- Data-type : Set
- -- Record type definition.
- Record : Set
-
- {-# BUILTIN AGDAFUNDEF Function #-}
- {-# BUILTIN AGDADATADEF Data-type #-}
- {-# BUILTIN AGDARECORDDEF Record #-}
-
- -- Definitions.
-
- data Definition : Set where
- function : Function → Definition
- data-type : Data-type → Definition
- record′ : Record → Definition
- constructor′ : Definition
- axiom : Definition
- primitive′ : Definition
-
- {-# BUILTIN AGDADEFINITION Definition #-}
- {-# BUILTIN AGDADEFINITIONFUNDEF function #-}
- {-# BUILTIN AGDADEFINITIONDATADEF data-type #-}
- {-# BUILTIN AGDADEFINITIONRECORDDEF record′ #-}
- {-# BUILTIN AGDADEFINITIONDATACONSTRUCTOR constructor′ #-}
- {-# BUILTIN AGDADEFINITIONPOSTULATE axiom #-}
- {-# BUILTIN AGDADEFINITIONPRIMITIVE primitive′ #-}
-
- primitive
- -- The type of the thing with the given name.
- primQNameType : Name → Type
- -- The definition of the thing with the given name.
- primQNameDefinition : Name → Definition
- -- The constructors of the given data type.
- primDataConstructors : Data-type → List Name
-
- As an example the expression
-
- primQNameType (quote zero)
-
- is definitionally equal to
-
- el (lit 0) (def (quote ℕ) [])
-
- (if zero is a constructor of the data type ℕ).
-
-* New keyword: unquote.
-
- The construction "unquote t" converts a representation of an Agda term
- to actual Agda code in the following way:
-
- 1. The argument t must have type Term (see the reflection API above).
-
- 2. The argument is normalised.
-
- 3. The entire construction is replaced by the normal form, which is
- treated as syntax written by the user and type-checked in the
- usual way.
-
- Examples:
-
- test : unquote (def (quote ℕ) []) ≡ ℕ
- test = refl
-
- id : (A : Set) → A → A
- id = unquote (lam visible (lam visible (var 0 [])))
-
- id-ok : id ≡ (λ A (x : A) → x)
- id-ok = refl
-
-* New keyword: quoteTerm.
-
- The construction "quoteTerm t" is similar to "quote n", but whereas
- quote is restricted to names n, quoteTerm accepts terms t. The
- construction is handled in the following way:
-
- 1. The type of t is inferred. The term t must be type-correct.
-
- 2. The term t is normalised.
-
- 3. The construction is replaced by the Term representation (see the
- reflection API above) of the normal form. Any unsolved metavariables
- in the term are represented by the "unknown" term constructor.
-
- Examples:
-
- test₁ : quoteTerm (λ {A : Set} (x : A) → x) ≡
- lam hidden (lam visible (var 0 []))
- test₁ = refl
-
- -- Local variables are represented as de Bruijn indices.
- test₂ : (λ {A : Set} (x : A) → quoteTerm x) ≡ (λ x → var 0 [])
- test₂ = refl
-
- -- Terms are normalised before being quoted.
- test₃ : quoteTerm (0 + 0) ≡ con (quote zero) []
- test₃ = refl
-
-Compiler backends
-=================
-
-MAlonzo
--------
-
-* The MAlonzo backend's FFI now handles universe polymorphism in a
- better way.
-
- The translation of Agda types and kinds into Haskell now supports
- universe-polymorphic postulates. The core changes are that the
- translation of function types has been changed from
-
- T[[ Pi (x : A) B ]] =
- if A has a Haskell kind then
- forall x. () -> T[[ B ]]
- else if x in fv B then
- undef
- else
- T[[ A ]] -> T[[ B ]]
-
- into
-
- T[[ Pi (x : A) B ]] =
- if x in fv B then
- forall x. T[[ A ]] -> T[[ B ]] -- Note: T[[A]] not Unit.
- else
- T[[ A ]] -> T[[ B ]],
-
- and that the translation of constants (postulates, constructors and
- literals) has been changed from
-
- T[[ k As ]] =
- if COMPILED_TYPE k T then
- T T[[ As ]]
- else
- undef
-
- into
-
- T[[ k As ]] =
- if COMPILED_TYPE k T then
- T T[[ As ]]
- else if COMPILED k E then
- ()
- else
- undef.
-
- For instance, assuming a Haskell definition
-
- type AgdaIO a b = IO b,
-
- we can set up universe-polymorphic IO in the following way:
-
- postulate
- IO : ∀ {ℓ} → Set ℓ → Set ℓ
- return : ∀ {a} {A : Set a} → A → IO A
- _>>=_ : ∀ {a b} {A : Set a} {B : Set b} →
- IO A → (A → IO B) → IO B
-
- {-# COMPILED_TYPE IO AgdaIO #-}
- {-# COMPILED return (\_ _ -> return) #-}
- {-# COMPILED _>>=_ (\_ _ _ _ -> (>>=)) #-}
-
- This is accepted because (assuming that the universe level type is
- translated to the Haskell unit type "()")
-
- (\_ _ -> return)
- : forall a. () -> forall b. () -> b -> AgdaIO a b
- = T [[ ∀ {a} {A : Set a} → A → IO A ]]
-
- and
-
- (\_ _ _ _ -> (>>=))
- : forall a. () -> forall b. () ->
- forall c. () -> forall d. () ->
- AgdaIO a c -> (c -> AgdaIO b d) -> AgdaIO b d
- = T [[ ∀ {a b} {A : Set a} {B : Set b} →
- IO A → (A → IO B) → IO B ]].
-
-Epic
-----
-
-* New Epic backend pragma: STATIC.
-
- In the Epic backend, functions marked with the STATIC pragma will be
- normalised before compilation. Example usage:
-
- {-# STATIC power #-}
-
- power : ℕ → ℕ → ℕ
- power 0 x = 1
- power 1 x = x
- power (suc n) x = power n x * x
-
- Occurrences of "power 4 x" will be replaced by "((x * x) * x) * x".
-
-* Some new optimisations have been implemented in the Epic backend:
-
- - Removal of unused arguments.
-
- A worker/wrapper transformation is performed so that unused
- arguments can be removed by Epic's inliner. For instance, the map
- function is transformed in the following way:
-
- map_wrap : (A B : Set) → (A → B) → List A → List B
- map_wrap A B f xs = map_work f xs
-
- map_work f [] = []
- map_work f (x ∷ xs) = f x ∷ map_work f xs
-
- If map_wrap is inlined (which it will be in any saturated call),
- then A and B disappear in the generated code.
-
- Unused arguments are found using abstract interpretation. The bodies
- of all functions in a module are inspected to decide which variables
- are used. The behaviour of postulates is approximated based on their
- types. Consider return, for instance:
-
- postulate return : {A : Set} → A → IO A
-
- The first argument of return can be removed, because it is of type
- Set and thus cannot affect the outcome of a program at runtime.
-
- - Injection detection.
-
- At runtime many functions may turn out to be inefficient variants of
- the identity function. This is especially true after forcing.
- Injection detection replaces some of these functions with more
- efficient versions. Example:
-
- inject : {n : ℕ} → Fin n → Fin (1 + n)
- inject {suc n} zero = zero
- inject {suc n} (suc i) = suc (inject {n} i)
-
- Forcing removes the Fin constructors' ℕ arguments, so this function
- is an inefficient identity function that can be replaced by the
- following one:
-
- inject {_} x = x
-
- To actually find this function, we make the induction hypothesis
- that inject is an identity function in its second argument and look
- at the branches of the function to decide if this holds.
-
- Injection detection also works over data type barriers. Example:
-
- forget : {A : Set} {n : ℕ} → Vec A n → List A
- forget [] = []
- forget (x ∷ xs) = x ∷ forget xs
-
- Given that the constructor tags (in the compiled Epic code) for
- Vec.[] and List.[] are the same, and that the tags for Vec._∷_ and
- List._∷_ are also the same, this is also an identity function. We
- can hence replace the definition with the following one:
-
- forget {_} xs = xs
-
- To get this to apply as often as possible, constructor tags are
- chosen /after/ injection detection has been run, in a way to make as
- many functions as possible injections.
-
- Constructor tags are chosen once per source file, so it may be
- advantageous to define conversion functions like forget in the same
- module as one of the data types. For instance, if Vec.agda imports
- List.agda, then the forget function should be put in Vec.agda to
- ensure that vectors and lists get the same tags (unless some other
- injection function, which puts different constraints on the tags, is
- prioritised).
-
- - Smashing.
-
- This optimisation finds types whose values are inferable at runtime:
-
- * A data type with only one constructor where all fields are
- inferable is itself inferable.
- * Set ℓ is inferable (as it has no runtime representation).
-
- A function returning an inferable data type can be smashed, which
- means that it is replaced by a function which simply returns the
- inferred value.
-
- An important example of an inferable type is the usual propositional
- equality type (_≡_). Any function returning a propositional equality
- can simply return the reflexivity constructor directly without
- computing anything.
-
- This optimisation makes more arguments unused. It also makes the
- Epic code size smaller, which in turn speeds up compilation.
-
-JavaScript
-----------
-
-* ECMAScript compiler backend.
-
- A new compiler backend is being implemented, targetting ECMAScript
- (also known as JavaScript), with the goal of allowing Agda programs
- to be run in browsers or other ECMAScript environments.
-
- The backend is still at an experimental stage: the core language is
- implemented, but many features are still missing.
-
- The ECMAScript compiler can be invoked from the command line using
- the flag --js:
-
- agda --js --compile-dir=<DIR> <FILE>.agda
-
- Each source <FILE>.agda is compiled into an ECMAScript target
- <DIR>/jAgda.<TOP-LEVEL MODULE NAME>.js. The compiler can also be
- invoked using the Emacs mode (the variable agda2-backend controls
- which backend is used).
-
- Note that ECMAScript is a strict rather than lazy language. Since
- Agda programs are total, this should not impact program semantics,
- but it may impact their space or time usage.
-
- ECMAScript does not support algebraic datatypes or pattern-matching.
- These features are translated to a use of the visitor pattern. For
- instance, the standard library's List data type and null function
- are translated into the following code:
-
- exports["List"] = {};
- exports["List"]["[]"] = function (x0) {
- return x0["[]"]();
- };
- exports["List"]["_∷_"] = function (x0) {
- return function (x1) {
- return function (x2) {
- return x2["_∷_"](x0, x1);
- };
- };
- };
-
- exports["null"] = function (x0) {
- return function (x1) {
- return function (x2) {
- return x2({
- "[]": function () {
- return jAgda_Data_Bool["Bool"]["true"];
- },
- "_∷_": function (x3, x4) {
- return jAgda_Data_Bool["Bool"]["false"];
- }
- });
- };
- };
- };
-
- Agda records are translated to ECMAScript objects, preserving field
- names.
-
- Top-level Agda modules are translated to ECMAScript modules,
- following the common.js module specification. A top-level Agda
- module "Foo.Bar" is translated to an ECMAScript module
- "jAgda.Foo.Bar".
-
- The ECMAScript compiler does not compile to Haskell, so the pragmas
- related to the Haskell FFI (IMPORT, COMPILED_DATA and COMPILED) are
- not used by the ECMAScript backend. Instead, there is a COMPILED_JS
- pragma which may be applied to any declaration. For postulates,
- primitives, functions and values, it gives the ECMAScript code to be
- emitted by the compiler. For data types, it gives a function which
- is applied to a value of that type, and a visitor object. For
- instance, a binding of natural numbers to ECMAScript integers
- (ignoring overflow errors) is:
-
- data ℕ : Set where
- zero : ℕ
- suc : ℕ → ℕ
-
- {-# COMPILED_JS ℕ function (x,v) {
- if (x < 1) { return v.zero(); } else { return v.suc(x-1); }
- } #-}
- {-# COMPILED_JS zero 0 #-}
- {-# COMPILED_JS suc function (x) { return x+1; } #-}
-
- _+_ : ℕ → ℕ → ℕ
- zero + n = n
- suc m + n = suc (m + n)
-
- {-# COMPILED_JS _+_ function (x) { return function (y) {
- return x+y; };
- } #-}
-
- To allow FFI code to be optimised, the ECMAScript in a COMPILED_JS
- declaration is parsed, using a simple parser that recognises a pure
- functional subset of ECMAScript, consisting of functions, function
- applications, return, if-statements, if-expressions,
- side-effect-free binary operators (no precedence, left associative),
- side-effect-free prefix operators, objects (where all member names
- are quoted), field accesses, and string and integer literals.
- Modules may be imported using the require("<module-id>") syntax: any
- impure code, or code outside the supported fragment, can be placed
- in a module and imported.
-
-Tools
-=====
-
-* New flag --safe, which can be used to type-check untrusted code.
-
- This flag disables postulates, primTrustMe, and "unsafe" OPTION
- pragmas, some of which are known to make Agda inconsistent.
-
- Rejected pragmas:
-
- --allow-unsolved-metas
- --experimental-irrelevance
- --guardedness-preserving-type-construtors
- --injective-type-constructors
- --no-coverage-check
- --no-positivity-check
- --no-termination-check
- --sized-types
- --type-in-type
-
- Note that, at the moment, it is not possible to define the universe
- level or coinduction primitives when --safe is used (because they
- must be introduced as postulates). This can be worked around by
- type-checking trusted files in a first pass, without using --safe,
- and then using --safe in a second pass. Modules which have already
- been type-checked are not re-type-checked just because --safe is
- used.
-
-* Dependency graphs.
-
- The new flag --dependency-graph=FILE can be used to generate a DOT
- file containing a module dependency graph. The generated file (FILE)
- can be rendered using a tool like dot.
-
-* The --no-unreachable-check flag has been removed.
-
-* Projection functions are highlighted as functions instead of as
- fields. Field names (in record definitions and record values) are
- still highlighted as fields.
-
-* Support for jumping to positions mentioned in the information
- buffer has been added.
-
-* The "make install" command no longer installs Agda globally (by
- default).
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.2.10
-------------------------------------------------------------------------
-
-Important changes since 2.2.8:
-
-Language
---------
-
-* New flag: --without-K.
-
- This flag makes pattern matching more restricted. If the flag is
- activated, then Agda only accepts certain case-splits. If the type
- of the variable to be split is D pars ixs, where D is a data (or
- record) type, pars stands for the parameters, and ixs the indices,
- then the following requirements must be satisfied:
-
- * The indices ixs must be applications of constructors to distinct
- variables.
-
- * These variables must not be free in pars.
-
- The intended purpose of --without-K is to enable experiments with a
- propositional equality without the K rule. Let us define
- propositional equality as follows:
-
- data _≡_ {A : Set} : A → A → Set where
- refl : ∀ x → x ≡ x
-
- Then the obvious implementation of the J rule is accepted:
-
- J : {A : Set} (P : {x y : A} → x ≡ y → Set) →
- (∀ x → P (refl x)) →
- ∀ {x y} (x≡y : x ≡ y) → P x≡y
- J P p (refl x) = p x
-
- The same applies to Christine Paulin-Mohring's version of the J rule:
-
- J′ : {A : Set} {x : A} (P : {y : A} → x ≡ y → Set) →
- P (refl x) →
- ∀ {y} (x≡y : x ≡ y) → P x≡y
- J′ P p (refl x) = p
-
- On the other hand, the obvious implementation of the K rule is not
- accepted:
-
- K : {A : Set} (P : {x : A} → x ≡ x → Set) →
- (∀ x → P (refl x)) →
- ∀ {x} (x≡x : x ≡ x) → P x≡x
- K P p (refl x) = p x
-
- However, we have /not/ proved that activation of --without-K ensures
- that the K rule cannot be proved in some other way.
-
-* Irrelevant declarations.
-
- Postulates and functions can be marked as irrelevant by prefixing
- the name with a dot when the name is declared. Example:
-
- postulate
- .irrelevant : {A : Set} → .A → A
-
- Irrelevant names may only be used in irrelevant positions or in
- definitions of things which have been declared irrelevant.
-
- The axiom irrelevant above can be used to define a projection from
- an irrelevant record field:
-
- data Subset (A : Set) (P : A → Set) : Set where
- _#_ : (a : A) → .(P a) → Subset A P
-
- elem : ∀ {A P} → Subset A P → A
- elem (a # p) = a
-
- .certificate : ∀ {A P} (x : Subset A P) → P (elem x)
- certificate (a # p) = irrelevant p
-
- The right-hand side of certificate is relevant, so we cannot define
-
- certificate (a # p) = p
-
- (because p is irrelevant). However, certificate is declared to be
- irrelevant, so it can use the axiom irrelevant. Furthermore the
- first argument of the axiom is irrelevant, which means that
- irrelevant p is well-formed.
-
- As shown above the axiom irrelevant justifies irrelevant
- projections. Previously no projections were generated for irrelevant
- record fields, such as the field certificate in the following
- record type:
-
- record Subset (A : Set) (P : A → Set) : Set where
- constructor _#_
- field
- elem : A
- .certificate : P elem
-
- Now projections are generated automatically for irrelevant fields
- (unless the flag --no-irrelevant-projections is used). Note that
- irrelevant projections are highly experimental.
-
-* Termination checker recognises projections.
-
- Projections now preserve sizes, both in patterns and expressions.
- Example:
-
- record Wrap (A : Set) : Set where
- constructor wrap
- field
- unwrap : A
-
- open Wrap public
-
- data WNat : Set where
- zero : WNat
- suc : Wrap WNat → WNat
-
- id : WNat → WNat
- id zero = zero
- id (suc w) = suc (wrap (id (unwrap w)))
-
- In the structural ordering unwrap w ≤ w. This means that
-
- unwrap w ≤ w < suc w,
-
- and hence the recursive call to id is accepted.
-
- Projections also preserve guardedness.
-
-Tools
------
-
-* Hyperlinks for top-level module names now point to the start of the
- module rather than to the declaration of the module name. This
- applies both to the Emacs mode and to the output of agda --html.
-
-* Most occurrences of record field names are now highlighted as
- "fields". Previously many occurrences were highlighted as
- "functions".
-
-* Emacs mode: It is no longer possible to change the behaviour of the
- TAB key by customising agda2-indentation.
-
-* Epic compiler backend.
-
- A new compiler backend is being implemented. This backend makes use
- of Edwin Brady's language Epic
- (http://www.cs.st-andrews.ac.uk/~eb/epic.php) and its compiler. The
- backend should handle most Agda code, but is still at an
- experimental stage: more testing is needed, and some things written
- below may not be entirely true.
-
- The Epic compiler can be invoked from the command line using the
- flag --epic:
-
- agda --epic --epic-flag=<EPIC-FLAG> --compile-dir=<DIR> <FILE>.agda
-
- The --epic-flag flag can be given multiple times; each flag is given
- verbatim to the Epic compiler (in the given order). The resulting
- executable is named after the main module and placed in the
- directory specified by the --compile-dir flag (default: the project
- root). Intermediate files are placed in a subdirectory called Epic.
-
- The backend requires that there is a definition named main. This
- definition should be a value of type IO Unit, but at the moment this
- is not checked (so it is easy to produce a program which segfaults).
- Currently the backend represents actions of type IO A as functions
- from Unit to A, and main is applied to the unit value.
-
- The Epic compiler compiles via C, not Haskell, so the pragmas
- related to the Haskell FFI (IMPORT, COMPILED_DATA and COMPILED) are
- not used by the Epic backend. Instead there is a new pragma
- COMPILED_EPIC. This pragma is used to give Epic code for postulated
- definitions (Epic code can in turn call C code). The form of the
- pragma is {-# COMPILED_EPIC def code #-}, where def is the name of
- an Agda postulate and code is some Epic code which should include
- the function arguments, return type and function body. As an example
- the IO monad can be defined as follows:
-
- postulate
- IO : Set → Set
- return : ∀ {A} → A → IO A
- _>>=_ : ∀ {A B} → IO A → (A → IO B) → IO B
-
- {-# COMPILED_EPIC return (u : Unit, a : Any) -> Any =
- ioreturn(a) #-}
- {-# COMPILED_EPIC
- _>>=_ (u1 : Unit, u2 : Unit, x : Any, f : Any) -> Any =
- iobind(x,f) #-}
-
- Here ioreturn and iobind are Epic functions which are defined in the
- file AgdaPrelude.e which is always included.
-
- By default the backend will remove so-called forced constructor
- arguments (and case-splitting on forced variables will be
- rewritten). This optimisation can be disabled by using the flag
- --no-forcing.
-
- All data types which look like unary natural numbers after forced
- constructor arguments have been removed (i.e. types with two
- constructors, one nullary and one with a single recursive argument)
- will be represented as "BigInts". This applies to the standard Fin
- type, for instance.
-
- The backend supports Agda's primitive functions and the BUILTIN
- pragmas. If the BUILTIN pragmas for unary natural numbers are used,
- then some operations, like addition and multiplication, will use
- more efficient "BigInt" operations.
-
- If you want to make use of the Epic backend you need to install some
- dependencies, see the README.
-
-* The Emacs mode can compile using either the MAlonzo or the Epic
- backend. The variable agda2-backend controls which backend is used.
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.2.8
-------------------------------------------------------------------------
-
-Important changes since 2.2.6:
-
-Language
---------
-
-* Record pattern matching.
-
- It is now possible to pattern match on named record constructors.
- Example:
-
- record Σ (A : Set) (B : A → Set) : Set where
- constructor _,_
- field
- proj₁ : A
- proj₂ : B proj₁
-
- map : {A B : Set} {P : A → Set} {Q : B → Set}
- (f : A → B) → (∀ {x} → P x → Q (f x)) →
- Σ A P → Σ B Q
- map f g (x , y) = (f x , g y)
-
- The clause above is internally translated into the following one:
-
- map f g p = (f (Σ.proj₁ p) , g (Σ.proj₂ p))
-
- Record patterns containing data type patterns are not translated.
- Example:
-
- add : ℕ × ℕ → ℕ
- add (zero , n) = n
- add (suc m , n) = suc (add (m , n))
-
- Record patterns which do not contain data type patterns, but which
- do contain dot patterns, are currently rejected. Example:
-
- Foo : {A : Set} (p₁ p₂ : A × A) → proj₁ p₁ ≡ proj₁ p₂ → Set₁
- Foo (x , y) (.x , y′) refl = Set
-
-* Proof irrelevant function types.
-
- Agda now supports irrelevant non-dependent function types:
-
- f : .A → B
-
- This type implies that f does not depend computationally on its
- argument. One intended use case is data structures with embedded
- proofs, like sorted lists:
-
- postulate
- _≤_ : ℕ → ℕ → Set
- p₁ : 0 ≤ 1
- p₂ : 0 ≤ 1
-
- data SList (bound : ℕ) : Set where
- [] : SList bound
- scons : (head : ℕ) →
- .(head ≤ bound) →
- (tail : SList head) →
- SList bound
-
- The effect of the irrelevant type in the signature of scons is that
- scons's second argument is never inspected after Agda has ensured
- that it has the right type. It is even thrown away, leading to
- smaller term sizes and hopefully some gain in efficiency. The
- type-checker ignores irrelevant arguments when checking equality, so
- two lists can be equal even if they contain different proofs:
-
- l₁ : SList 1
- l₁ = scons 0 p₁ []
-
- l₂ : SList 1
- l₂ = scons 0 p₂ []
-
- l₁≡l₂ : l₁ ≡ l₂
- l₁≡l₂ = refl
-
- Irrelevant arguments can only be used in irrelevant contexts.
- Consider the following subset type:
-
- data Subset (A : Set) (P : A → Set) : Set where
- _#_ : (elem : A) → .(P elem) → Subset A P
-
- The following two uses are fine:
-
- elimSubset : ∀ {A C : Set} {P} →
- Subset A P → ((a : A) → .(P a) → C) → C
- elimSubset (a # p) k = k a p
-
- elem : {A : Set} {P : A → Set} → Subset A P → A
- elem (x # p) = x
-
- However, if we try to project out the proof component, then Agda
- complains that "variable p is declared irrelevant, so it cannot be
- used here":
-
- prjProof : ∀ {A P} (x : Subset A P) → P (elem x)
- prjProof (a # p) = p
-
- Matching against irrelevant arguments is also forbidden, except in
- the case of irrefutable matches (record constructor patterns which
- have been translated away). For instance, the match against the
- pattern (p , q) here is accepted:
-
- elim₂ : ∀ {A C : Set} {P Q : A → Set} →
- Subset A (λ x → Σ (P x) (λ _ → Q x)) →
- ((a : A) → .(P a) → .(Q a) → C) → C
- elim₂ (a # (p , q)) k = k a p q
-
- Absurd matches () are also allowed.
-
- Note that record fields can also be irrelevant. Example:
-
- record Subset (A : Set) (P : A → Set) : Set where
- constructor _#_
- field
- elem : A
- .proof : P elem
-
- Irrelevant fields are never in scope, neither inside nor outside the
- record. This means that no record field can depend on an irrelevant
- field, and furthermore projections are not defined for such fields.
- Irrelevant fields can only be accessed using pattern matching, as in
- elimSubset above.
-
- Irrelevant function types were added very recently, and have not
- been subjected to much experimentation yet, so do not be surprised
- if something is changed before the next release. For instance,
- dependent irrelevant function spaces (.(x : A) → B) might be added
- in the future.
-
-* Mixfix binders.
-
- It is now possible to declare user-defined syntax that binds
- identifiers. Example:
-
- postulate
- State : Set → Set → Set
- put : ∀ {S} → S → State S ⊤
- get : ∀ {S} → State S S
- return : ∀ {A S} → A → State S A
- bind : ∀ {A B S} → State S B → (B → State S A) → State S A
-
- syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂
-
- increment : State ℕ ⊤
- increment = x ← get ,
- put (1 + x)
-
- The syntax declaration for bind implies that x is in scope in e₂,
- but not in e₁.
-
- You can give fixity declarations along with syntax declarations:
-
- infixr 40 bind
- syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂
-
- The fixity applies to the syntax, not the name; syntax declarations
- are also restricted to ordinary, non-operator names. The following
- declaration is disallowed:
-
- syntax _==_ x y = x === y
-
- Syntax declarations must also be linear; the following declaration
- is disallowed:
-
- syntax wrong x = x + x
-
- Syntax declarations were added very recently, and have not been
- subjected to much experimentation yet, so do not be surprised if
- something is changed before the next release.
-
-* Prop has been removed from the language.
-
- The experimental sort Prop has been disabled. Any program using Prop
- should typecheck if Prop is replaced by Set₀. Note that Prop is still
- a keyword.
-
-* Injective type constructors off by default.
-
- Automatic injectivity of type constructors has been disabled (by
- default). To enable it, use the flag --injective-type-constructors,
- either on the command line or in an OPTIONS pragma. Note that this
- flag makes Agda anti-classical and possibly inconsistent:
-
- Agda with excluded middle is inconsistent
- http://thread.gmane.org/gmane.comp.lang.agda/1367
-
- See test/Succeed/InjectiveTypeConstructors.agda for an example.
-
-* Termination checker can count.
-
- There is a new flag --termination-depth=N accepting values N >= 1
- (with N = 1 being the default) which influences the behavior of the
- termination checker. So far, the termination checker has only
- distinguished three cases when comparing the argument of a recursive
- call with the formal parameter of the callee.
-
- < : the argument is structurally smaller than the parameter
- = : they are equal
- ? : the argument is bigger or unrelated to the parameter
-
- This behavior, which is still the default (N = 1), will not
- recognise the following functions as terminating.
-
- mutual
-
- f : ℕ → ℕ
- f zero = zero
- f (suc zero) = zero
- f (suc (suc n)) = aux n
-
- aux : ℕ → ℕ
- aux m = f (suc m)
-
- The call graph
-
- f --(<)--> aux --(?)--> f
-
- yields a recursive call from f to f via aux where the relation of
- call argument to callee parameter is computed as "unrelated"
- (composition of < and ?).
-
- Setting N >= 2 allows a finer analysis: n has two constructors less
- than suc (suc n), and suc m has one more than m, so we get the call
- graph:
-
- f --(-2)--> aux --(+1)--> f
-
- The indirect call f --> f is now labeled with (-1), and the
- termination checker can recognise that the call argument is
- decreasing on this path.
-
- Setting the termination depth to N means that the termination
- checker counts decrease up to N and increase up to N-1. The default,
- N=1, means that no increase is counted, every increase turns to
- "unrelated".
-
- In practice, examples like the one above sometimes arise when "with"
- is used. As an example, the program
-
- f : ℕ → ℕ
- f zero = zero
- f (suc zero) = zero
- f (suc (suc n)) with zero
- ... | _ = f (suc n)
-
- is internally represented as
-
- mutual
-
- f : ℕ → ℕ
- f zero = zero
- f (suc zero) = zero
- f (suc (suc n)) = aux n zero
-
- aux : ℕ → ℕ → ℕ
- aux m k = f (suc m)
-
- Thus, by default, the definition of f using "with" is not accepted
- by the termination checker, even though it looks structural (suc n
- is a subterm of suc suc n). Now, the termination checker is
- satisfied if the option "--termination-depth=2" is used.
-
- Caveats:
-
- - This is an experimental feature, hopefully being replaced by
- something smarter in the near future.
-
- - Increasing the termination depth will quickly lead to very long
- termination checking times. So, use with care. Setting termination
- depth to 100 by habit, just to be on the safe side, is not a good
- idea!
-
- - Increasing termination depth only makes sense for linear data
- types such as ℕ and Size. For other types, increase cannot be
- recognised. For instance, consider a similar example with lists.
-
- data List : Set where
- nil : List
- cons : ℕ → List → List
-
- mutual
- f : List → List
- f nil = nil
- f (cons x nil) = nil
- f (cons x (cons y ys)) = aux y ys
-
- aux : ℕ → List → List
- aux z zs = f (cons z zs)
-
- Here the termination checker compares cons z zs to z and also to
- zs. In both cases, the result will be "unrelated", no matter how
- high we set the termination depth. This is because when comparing
- cons z zs to zs, for instance, z is unrelated to zs, thus,
- cons z zs is also unrelated to zs. We cannot say it is just "one
- larger" since z could be a very large term. Note that this points
- to a weakness of untyped termination checking.
-
- To regain the benefit of increased termination depth, we need to
- index our lists by a linear type such as ℕ or Size. With
- termination depth 2, the above example is accepted for vectors
- instead of lists.
-
-* The codata keyword has been removed. To use coinduction, use the
- following new builtins: INFINITY, SHARP and FLAT. Example:
-
- {-# OPTIONS --universe-polymorphism #-}
-
- module Coinduction where
-
- open import Level
-
- infix 1000 ♯_
-
- postulate
- ∞ : ∀ {a} (A : Set a) → Set a
- ♯_ : ∀ {a} {A : Set a} → A → ∞ A
- ♭ : ∀ {a} {A : Set a} → ∞ A → A
-
- {-# BUILTIN INFINITY ∞ #-}
- {-# BUILTIN SHARP ♯_ #-}
- {-# BUILTIN FLAT ♭ #-}
-
- Note that (non-dependent) pattern matching on SHARP is no longer
- allowed.
-
- Note also that strange things might happen if you try to combine the
- pragmas above with COMPILED_TYPE, COMPILED_DATA or COMPILED pragmas,
- or if the pragmas do not occur right after the postulates.
-
- The compiler compiles the INFINITY builtin to nothing (more or
- less), so that the use of coinduction does not get in the way of FFI
- declarations:
-
- data Colist (A : Set) : Set where
- [] : Colist A
- _∷_ : (x : A) (xs : ∞ (Colist A)) → Colist A
-
- {-# COMPILED_DATA Colist [] [] (:) #-}
-
-* Infinite types.
-
- If the new flag --guardedness-preserving-type-constructors is used,
- then type constructors are treated as inductive constructors when we
- check productivity (but only in parameters, and only if they are
- used strictly positively or not at all). This makes examples such as
- the following possible:
-
- data Rec (A : ∞ Set) : Set where
- fold : ♭ A → Rec A
-
- -- Σ cannot be a record type below.
-
- data Σ (A : Set) (B : A → Set) : Set where
- _,_ : (x : A) → B x → Σ A B
-
- syntax Σ A (λ x → B) = Σ[ x ∶ A ] B
-
- -- Corecursive definition of the W-type.
-
- W : (A : Set) → (A → Set) → Set
- W A B = Rec (♯ (Σ[ x ∶ A ] (B x → W A B)))
-
- syntax W A (λ x → B) = W[ x ∶ A ] B
-
- sup : {A : Set} {B : A → Set} (x : A) (f : B x → W A B) → W A B
- sup x f = fold (x , f)
-
- W-rec : {A : Set} {B : A → Set}
- (P : W A B → Set) →
- (∀ {x} {f : B x → W A B} → (∀ y → P (f y)) → P (sup x f)) →
- ∀ x → P x
- W-rec P h (fold (x , f)) = h (λ y → W-rec P h (f y))
-
- -- Induction-recursion encoded as corecursion-recursion.
-
- data Label : Set where
- ′0 ′1 ′2 ′σ ′π ′w : Label
-
- mutual
-
- U : Set
- U = Σ Label U′
-
- U′ : Label → Set
- U′ ′0 = ⊤
- U′ ′1 = ⊤
- U′ ′2 = ⊤
- U′ ′σ = Rec (♯ (Σ[ a ∶ U ] (El a → U)))
- U′ ′π = Rec (♯ (Σ[ a ∶ U ] (El a → U)))
- U′ ′w = Rec (♯ (Σ[ a ∶ U ] (El a → U)))
-
- El : U → Set
- El (′0 , _) = ⊥
- El (′1 , _) = ⊤
- El (′2 , _) = Bool
- El (′σ , fold (a , b)) = Σ[ x ∶ El a ] El (b x)
- El (′π , fold (a , b)) = (x : El a) → El (b x)
- El (′w , fold (a , b)) = W[ x ∶ El a ] El (b x)
-
- U-rec : (P : ∀ u → El u → Set) →
- P (′1 , _) tt →
- P (′2 , _) true →
- P (′2 , _) false →
- (∀ {a b x y} →
- P a x → P (b x) y → P (′σ , fold (a , b)) (x , y)) →
- (∀ {a b f} →
- (∀ x → P (b x) (f x)) → P (′π , fold (a , b)) f) →
- (∀ {a b x f} →
- (∀ y → P (′w , fold (a , b)) (f y)) →
- P (′w , fold (a , b)) (sup x f)) →
- ∀ u (x : El u) → P u x
- U-rec P P1 P2t P2f Pσ Pπ Pw = rec
- where
- rec : ∀ u (x : El u) → P u x
- rec (′0 , _) ()
- rec (′1 , _) _ = P1
- rec (′2 , _) true = P2t
- rec (′2 , _) false = P2f
- rec (′σ , fold (a , b)) (x , y) = Pσ (rec _ x) (rec _ y)
- rec (′π , fold (a , b)) f = Pπ (λ x → rec _ (f x))
- rec (′w , fold (a , b)) (fold (x , f)) = Pw (λ y → rec _ (f y))
-
- The --guardedness-preserving-type-constructors extension is based on
- a rather operational understanding of ∞/♯_; it's not yet clear if
- this extension is consistent.
-
-* Qualified constructors.
-
- Constructors can now be referred to qualified by their data type.
- For instance, given
-
- data Nat : Set where
- zero : Nat
- suc : Nat → Nat
-
- data Fin : Nat → Set where
- zero : ∀ {n} → Fin (suc n)
- suc : ∀ {n} → Fin n → Fin (suc n)
-
- you can refer to the constructors unambiguously as Nat.zero,
- Nat.suc, Fin.zero, and Fin.suc (Nat and Fin are modules containing
- the respective constructors). Example:
-
- inj : (n m : Nat) → Nat.suc n ≡ suc m → n ≡ m
- inj .m m refl = refl
-
- Previously you had to write something like
-
- inj : (n m : Nat) → _≡_ {Nat} (suc n) (suc m) → n ≡ m
-
- to make the type checker able to figure out that you wanted the
- natural number suc in this case.
-
-* Reflection.
-
- There are two new constructs for reflection:
-
- - quoteGoal x in e
-
- In e the value of x will be a representation of the goal type
- (the type expected of the whole expression) as an element in a
- datatype of Agda terms (see below). For instance,
-
- example : ℕ
- example = quoteGoal x in {! at this point x = def (quote ℕ) [] !}
-
- - quote x : Name
-
- If x is the name of a definition (function, datatype, record, or
- a constructor), quote x gives you the representation of x as a
- value in the primitive type Name (see below).
-
- Quoted terms use the following BUILTINs and primitives (available
- from the standard library module Reflection):
-
- -- The type of Agda names.
-
- postulate Name : Set
-
- {-# BUILTIN QNAME Name #-}
-
- primitive primQNameEquality : Name → Name → Bool
-
- -- Arguments.
-
- Explicit? = Bool
-
- data Arg A : Set where
- arg : Explicit? → A → Arg A
-
- {-# BUILTIN ARG Arg #-}
- {-# BUILTIN ARGARG arg #-}
-
- -- The type of Agda terms.
-
- data Term : Set where
- var : ℕ → List (Arg Term) → Term
- con : Name → List (Arg Term) → Term
- def : Name → List (Arg Term) → Term
- lam : Explicit? → Term → Term
- pi : Arg Term → Term → Term
- sort : Term
- unknown : Term
-
- {-# BUILTIN AGDATERM Term #-}
- {-# BUILTIN AGDATERMVAR var #-}
- {-# BUILTIN AGDATERMCON con #-}
- {-# BUILTIN AGDATERMDEF def #-}
- {-# BUILTIN AGDATERMLAM lam #-}
- {-# BUILTIN AGDATERMPI pi #-}
- {-# BUILTIN AGDATERMSORT sort #-}
- {-# BUILTIN AGDATERMUNSUPPORTED unknown #-}
-
- Reflection may be useful when working with internal decision
- procedures, such as the standard library's ring solver.
-
-* Minor record definition improvement.
-
- The definition of a record type is now available when type checking
- record module definitions. This means that you can define things
- like the following:
-
- record Cat : Set₁ where
- field
- Obj : Set
- _=>_ : Obj → Obj → Set
- -- ...
-
- -- not possible before:
- op : Cat
- op = record { Obj = Obj; _=>_ = λ A B → B => A }
-
-Tools
------
-
-* The "Goal type and context" command now shows the goal type before
- the context, and the context is shown in reverse order. The "Goal
- type, context and inferred type" command has been modified in a
- similar way.
-
-* Show module contents command.
-
- Given a module name M the Emacs mode can now display all the
- top-level modules and names inside M, along with types for the
- names. The command is activated using C-c C-o or the menus.
-
-* Auto command.
-
- A command which searches for type inhabitants has been added. The
- command is invoked by pressing C-C C-a (or using the goal menu).
- There are several flags and parameters, e.g. '-c' which enables
- case-splitting in the search. For further information, see the Agda
- wiki:
-
- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Auto
-
-* HTML generation is now possible for a module with unsolved
- meta-variables, provided that the --allow-unsolved-metas flag is
- used.
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.2.6
-------------------------------------------------------------------------
-
-Important changes since 2.2.4:
-
-Language
---------
-
-* Universe polymorphism (experimental extension).
-
- To enable universe polymorphism give the flag
- --universe-polymorphism on the command line or (recommended) as an
- OPTIONS pragma.
-
- When universe polymorphism is enabled Set takes an argument which is
- the universe level. For instance, the type of universe polymorphic
- identity is
-
- id : {a : Level} {A : Set a} → A → A.
-
- The type Level is isomorphic to the unary natural numbers and should be
- specified using the BUILTINs LEVEL, LEVELZERO, and LEVELSUC:
-
- data Level : Set where
- zero : Level
- suc : Level → Level
-
- {-# BUILTIN LEVEL Level #-}
- {-# BUILTIN LEVELZERO zero #-}
- {-# BUILTIN LEVELSUC suc #-}
-
- There is an additional BUILTIN LEVELMAX for taking the maximum of two
- levels:
-
- max : Level → Level → Level
- max zero m = m
- max (suc n) zero = suc n
- max (suc n) (suc m) = suc (max n m)
-
- {-# BUILTIN LEVELMAX max #-}
-
- The non-polymorphic universe levels Set, Set₁ and so on are sugar
- for Set zero, Set (suc zero), etc.
-
- At present there is no automatic lifting of types from one level to
- another. It can still be done (rather clumsily) by defining types
- like the following one:
-
- data Lifted {a} (A : Set a) : Set (suc a) where
- lift : A → Lifted A
-
- However, it is likely that automatic lifting is introduced at some
- point in the future.
-
-* Multiple constructors, record fields, postulates or primitives can
- be declared using a single type signature:
-
- data Bool : Set where
- false true : Bool
-
- postulate
- A B : Set
-
-* Record fields can be implicit:
-
- record R : Set₁ where
- field
- {A} : Set
- f : A → A
- {B C} D {E} : Set
- g : B → C → E
-
- By default implicit fields are not printed.
-
-* Record constructors can be defined:
-
- record Σ (A : Set) (B : A → Set) : Set where
- constructor _,_
- field
- proj₁ : A
- proj₂ : B proj₁
-
- In this example _,_ gets the type
-
- (proj₁ : A) → B proj₁ → Σ A B.
-
- For implicit fields the corresponding constructor arguments become
- implicit.
-
- Note that the constructor is defined in the /outer/ scope, so any
- fixity declaration has to be given outside the record definition.
- The constructor is not in scope inside the record module.
-
- Note also that pattern matching for records has not been implemented
- yet.
-
-* BUILTIN hooks for equality.
-
- The data type
-
- data _≡_ {A : Set} (x : A) : A → Set where
- refl : x ≡ x
-
- can be specified as the builtin equality type using the following
- pragmas:
-
- {-# BUILTIN EQUALITY _≡_ #-}
- {-# BUILTIN REFL refl #-}
-
- The builtin equality is used for the new rewrite construct and
- the primTrustMe primitive described below.
-
-* New rewrite construct.
-
- If eqn : a ≡ b, where _≡_ is the builtin equality (see above) you
- can now write
-
- f ps rewrite eqn = rhs
-
- instead of
-
- f ps with a | eqn
- ... | ._ | refl = rhs
-
- The rewrite construct has the effect of rewriting the goal and the
- context by the given equation (left to right).
-
- You can rewrite using several equations (in sequence) by separating
- them with vertical bars (|):
-
- f ps rewrite eqn₁ | eqn₂ | … = rhs
-
- It is also possible to add with clauses after rewriting:
-
- f ps rewrite eqns with e
- ... | p = rhs
-
- Note that pattern matching happens before rewriting—if you want to
- rewrite and then do pattern matching you can use a with after the
- rewrite.
-
- See test/Succeed/Rewrite.agda for some examples.
-
-* A new primitive, primTrustMe, has been added:
-
- primTrustMe : {A : Set} {x y : A} → x ≡ y
-
- Here _≡_ is the builtin equality (see BUILTIN hooks for equality,
- above).
-
- If x and y are definitionally equal, then
- primTrustMe {x = x} {y = y} reduces to refl.
-
- Note that the compiler replaces all uses of primTrustMe with the
- REFL builtin, without any check for definitional equality. Incorrect
- uses of primTrustMe can potentially lead to segfaults or similar
- problems.
-
- For an example of the use of primTrustMe, see Data.String in version
- 0.3 of the standard library, where it is used to implement decidable
- equality on strings using the primitive boolean equality.
-
-* Changes to the syntax and semantics of IMPORT pragmas, which are
- used by the Haskell FFI. Such pragmas must now have the following
- form:
-
- {-# IMPORT <module name> #-}
-
- These pragmas are interpreted as /qualified/ imports, so Haskell
- names need to be given qualified (unless they come from the Haskell
- prelude).
-
-* The horizontal tab character (U+0009) is no longer treated as white
- space.
-
-* Line pragmas are no longer supported.
-
-* The --include-path flag can no longer be used as a pragma.
-
-* The experimental and incomplete support for proof irrelevance has
- been disabled.
-
-Tools
------
-
-* New "intro" command in the Emacs mode. When there is a canonical way
- of building something of the goal type (for instance, if the goal
- type is a pair), the goal can be refined in this way. The command
- works for the following goal types:
-
- - A data type where only one of its constructors can be used to
- construct an element of the goal type. (For instance, if the
- goal is a non-empty vector, a "cons" will be introduced.)
-
- - A record type. A record value will be introduced. Implicit
- fields will not be included unless showing of implicit arguments
- is switched on.
-
- - A function type. A lambda binding as many variables as possible
- will be introduced. The variable names will be chosen from the
- goal type if its normal form is a dependent function type,
- otherwise they will be variations on "x". Implicit lambdas will
- only be inserted if showing of implicit arguments is switched
- on.
-
- This command can be invoked by using the refine command (C-c C-r)
- when the goal is empty. (The old behaviour of the refine command in
- this situation was to ask for an expression using the minibuffer.)
-
-* The Emacs mode displays "Checked" in the mode line if the current
- file type checked successfully without any warnings.
-
-* If a file F is loaded, and this file defines the module M, it is an
- error if F is not the file which defines M according to the include
- path.
-
- Note that the command-line tool and the Emacs mode define the
- meaning of relative include paths differently: the command-line tool
- interprets them relative to the current working directory, whereas
- the Emacs mode interprets them relative to the root directory of the
- current project. (As an example, if the module A.B.C is loaded from
- the file <some-path>/A/B/C.agda, then the root directory is
- <some-path>.)
-
-* It is an error if there are several files on the include path which
- match a given module name.
-
-* Interface files are relocatable. You can move around source trees as
- long as the include path is updated in a corresponding way. Note
- that a module M may be re-typechecked if its time stamp is strictly
- newer than that of the corresponding interface file (M.agdai).
-
-* Type-checking is no longer done when an up-to-date interface exists.
- (Previously the initial module was always type-checked.)
-
-* Syntax highlighting files for Emacs (.agda.el) are no longer used.
- The --emacs flag has been removed. (Syntax highlighting information
- is cached in the interface files.)
-
-* The Agate and Alonzo compilers have been retired. The options
- --agate, --alonzo and --malonzo have been removed.
-
-* The default directory for MAlonzo output is the project's root
- directory. The --malonzo-dir flag has been renamed to --compile-dir.
-
-* Emacs mode: C-c C-x C-d no longer resets the type checking state.
- C-c C-x C-r can be used for a more complete reset. C-c C-x C-s
- (which used to reload the syntax highlighting information) has been
- removed. C-c C-l can be used instead.
-
-* The Emacs mode used to define some "abbrevs", unless the user
- explicitly turned this feature off. The new default is /not/ to add
- any abbrevs. The old default can be obtained by customising
- agda2-mode-abbrevs-use-defaults (a customisation buffer can be
- obtained by typing M-x customize-group agda2 RET after an Agda file
- has been loaded).
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.2.4
-------------------------------------------------------------------------
-
-Important changes since 2.2.2:
-
-* Change to the semantics of "open import" and "open module". The
- declaration
-
- open import M <using/hiding/renaming>
-
- now translates to
-
- import A
- open A <using/hiding/renaming>
-
- instead of
-
- import A <using/hiding/renaming>
- open A.
-
- The same translation is used for "open module M = E …". Declarations
- involving the keywords as or public are changed in a corresponding
- way ("as" always goes with import, and "public" always with open).
-
- This change means that import directives do not affect the qualified
- names when open import/module is used. To get the old behaviour you
- can use the expanded version above.
-
-* Names opened publicly in parameterised modules no longer inherit the
- module parameters. Example:
-
- module A where
- postulate X : Set
-
- module B (Y : Set) where
- open A public
-
- In Agda 2.2.2 B.X has type (Y : Set) → Set, whereas in Agda 2.2.4
- B.X has type Set.
-
-* Previously it was not possible to export a given constructor name
- through two different "open public" statements in the same module.
- This is now possible.
-
-* Unicode subscript digits are now allowed for the hierarchy of
- universes (Set₀, Set₁, …): Set₁ is equivalent to Set1.
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.2.2
-------------------------------------------------------------------------
-
-Important changes since 2.2.0:
-
-Tools
------
-
-* The --malonzodir option has been renamed to --malonzo-dir.
-
-* The output of agda --html is by default placed in a directory called
- "html".
-
-Infrastructure
---------------
-
-* The Emacs mode is included in the Agda Cabal package, and installed
- by cabal install. The recommended way to enable the Emacs mode is to
- include the following code in .emacs:
-
- (load-file (let ((coding-system-for-read 'utf-8))
- (shell-command-to-string "agda-mode locate")))
-
-------------------------------------------------------------------------
--- Release notes for Agda 2 version 2.2.0
-------------------------------------------------------------------------
-
-Important changes since 2.1.2 (which was released 2007-08-16):
-
-Language
---------
-
-* Exhaustive pattern checking. Agda complains if there are missing
- clauses in a function definition.
-
-* Coinductive types are supported. This feature is under
- development/evaluation, and may change.
-
- http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.Codatatypes
-
-* Another experimental feature: Sized types, which can make it easier
- to explain why your code is terminating.
-
-* Improved constraint solving for functions with constructor headed
- right hand sides.
-
- http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.FindingTheValuesOfImplicitArguments
-
-* A simple, well-typed foreign function interface, which allows use of
- Haskell functions in Agda code.
-
- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.FFI
-
-* The tokens forall, -> and \ can be written as ∀, → and λ.
-
-* Absurd lambdas: λ () and λ {}.
-
- http://thread.gmane.org/gmane.comp.lang.agda/440
-
-* Record fields whose values can be inferred can be omitted.
-
-* Agda complains if it spots an unreachable clause, or if a pattern
- variable "shadows" a hidden constructor of matching type.
-
- http://thread.gmane.org/gmane.comp.lang.agda/720
-
-Tools
------
-
-* Case-split: The user interface can replace a pattern variable with
- the corresponding constructor patterns. You get one new left-hand
- side for every possible constructor.
-
- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.QuickGuideToEditingTypeCheckingAndCompilingAgdaCode
-
-* The MAlonzo compiler.
-
- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.MAlonzo
-
-* A new Emacs input method, which contains bindings for many Unicode
- symbols, is by default activated in the Emacs mode.
-
- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.UnicodeInput
-
-* Highlighted, hyperlinked HTML can be generated from Agda source
- code.
-
- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.HowToGenerateWebPagesFromSourceCode
-
-* The command-line interactive mode (agda -I) is no longer supported,
- but should still work.
-
- http://thread.gmane.org/gmane.comp.lang.agda/245
-
-* Reload times when working on large projects are now considerably
- better.
-
- http://thread.gmane.org/gmane.comp.lang.agda/551
-
-Libraries
----------
-
-* A standard library is under development.
-
- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Libraries.StandardLibrary
-
-Documentation
--------------
-
-* The Agda wiki is better organised. It should be easier for a
- newcomer to find relevant information now.
-
- http://wiki.portal.chalmers.se/agda/
-
-Infrastructure
---------------
-
-* Easy-to-install packages for Windows and Debian/Ubuntu have been
- prepared.
-
- http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Download
-
-* Agda 2.2.0 is available from Hackage.
-
- http://hackage.haskell.org/
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..4d2fbf5
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,8782 @@
+Release notes for Agda version 2.5.2
+====================================
+
+Installation and infrastructure
+-------------------------------
+
+* Modular support for literate programming
+
+ Literate programming support has been moved out of the lexer and into the
+ `Agda.Syntax.Parser.Literate` module.
+
+ Files ending in `.lagda` are still interpreted as literate TeX.
+ The extension `.lagda.tex` may now also be used for literate TeX files.
+
+ Support for more literate code formats and extensions can be added
+ modularly.
+
+ By default, `.lagda.*` files are opened in the Emacs mode
+ corresponding to their last extension. One may switch to and from
+ Agda mode manually.
+
+* reStructuredText
+
+ Literate Agda code can now be written in reStructuredText format, using
+ the `.lagda.rst` extension.
+
+ As a general rule, Agda will parse code following a line ending in `::`,
+ as long as that line does not start with `..`. The module name must
+ match the path of the file in the documentation, and must be given
+ explicitly. Several files have been converted already, for instance:
+
+ - `language/mixfix-operators.lagda.rst`
+ - `tools/compilers.lagda.rst`
+
+ Note that:
+
+ - Code blocks inside an rST comment block will be type-checked by Agda,
+ but not rendered in the documentation.
+ - Code blocks delimited by `.. code-block:: agda` will be rendered in
+ the final documenation, but not type-checked by Agda.
+ - All lines inside a codeblock must be further indented than the first line
+ of the code block.
+ - Indentation must be consistent between code blocks. In other
+ words, the file as a whole must be a valid Agda file if all the
+ literate text is replaced by white space.
+
+* Documentation testing
+
+ All documentation files in the `doc/user-manual` directory that end
+ in `.lagda.rst` can be typechecked by running `make
+ user-manual-test`, and also as part of the general test suite.
+
+* Support installation through Stack
+
+ The Agda sources now also include a configuration for the stack install tool
+ (tested through continuous integration).
+
+ It should hence be possible to repeatably build any future Agda version
+ (including unreleased commits) from source by checking out that version and
+ running `stack install` from the checkout directory.
+ By using repeatable builds, this should keep selecting the same dependencies
+ in the face of new releases on Hackage.
+
+ For further motivation, see
+ Issue [#2005](https://github.com/agda/agda/issues/2005).
+
+* Removed the `--test` command-line option
+
+ This option ran the internal test-suite. This test-suite was
+ implemented using Cabal supports for
+ test-suites. [Issue [#2083](https://github.com/agda/agda/issues/2083)].
+
+* The `--no-default-libraries` flag has been split into two flags
+ [Issue [#1937](https://github.com/agda/agda/issues/1937)]
+
+ - `--no-default-libraries`: Ignore the defaults file but still look for local
+ `.agda-lib` files
+ - `--no-libraries`: Don't use any `.agda-lib` files (the previous behaviour
+ of `--no-default-libraries`).
+
+* If `agda` was built inside `git` repository, then the `--version` flag
+ will display the hash of the commit used, and whether the tree was
+ `-dirty` (i.e. there were uncommited changes in the working directory).
+ Otherwise, only the version number is shown.
+
+Language
+--------
+
+* Dot patterns are now optional
+
+ Consider the following program
+
+ ```agda
+ data Vec (A : Set) : Nat → Set where
+ [] : Vec A zero
+ cons : ∀ n → A → Vec A n → Vec A (suc n)
+
+ vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n
+ vmap .zero f [] = []
+ vmap .(suc m) f (cons m x xs) = cons m (f x) (vmap m f xs)
+ ```
+
+ If we don't care about the dot patterns they can (and could previously) be
+ replaced by wildcards:
+
+ ```agda
+ vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n
+ vmap _ f [] = []
+ vmap _ f (cons m x xs) = cons m (f x) (vmap m f xs)
+ ```
+
+ Now it is also allowed to give a variable pattern in place of the dot
+ pattern. In this case the variable will be bound to the value of the dot
+ pattern. For our example:
+
+ ```agda
+ vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n
+ vmap n f [] = []
+ vmap n f (cons m x xs) = cons m (f x) (vmap m f xs)
+ ```
+
+ In the first clause `n` reduces to `zero` and in the second clause
+ `n` reduces to `suc m`.
+
+* Module parameters can now be refined by pattern matching
+
+ Previously, pattern matches that would refine a variable outside the
+ current left-hand side was disallowed. For instance, the following
+ would give an error, since matching on the vector would
+ instantiate `n`.
+
+ ```agda
+ module _ {A : Set} {n : Nat} where
+ f : Vec A n → Vec A n
+ f [] = []
+ f (x ∷ xs) = x ∷ xs
+ ```
+
+ Now this is no longer disallowed. Instead `n` is bound to the
+ appropriate value in each clause.
+
+* With-abstraction now abstracts also in module parameters
+
+ The change that allows pattern matching to refine module parameters also
+ allows with-abstraction to abstract in them. For instance,
+
+ ```agda
+ module _ (n : Nat) (xs : Vec Nat (n + n)) where
+ f : Nat
+ f with n + n
+ f | nn = ? -- xs : Vec Nat nn
+ ```
+
+ Note: Any function argument or lambda-bound variable bound outside a given
+ function counts as a module parameter.
+
+ To prevent abstraction in a parameter you can hide it inside a definition. In
+ the above example,
+
+ ```agda
+ module _ (n : Nat) (xs : Vec Nat (n + n)) where
+
+ ys : Vec Nat (n + n)
+ ys = xs
+
+ f : Nat
+ f with n + n
+ f | nn = ? -- xs : Vec Nat nn, ys : Vec Nat (n + n)
+ ```
+
+* As-patterns [Issue [#78](https://github.com/agda/agda/issues/78)].
+
+ As-patterns (`@`-patterns) are finally working and can be used to name a
+ pattern. The name has the same scope as normal pattern variables (i.e. the
+ right-hand side, where clause, and dot patterns). The name reduces to the
+ value of the named pattern. For example::
+
+ ```agda
+ module _ {A : Set} (_<_ : A → A → Bool) where
+ merge : List A → List A → List A
+ merge xs [] = xs
+ merge [] ys = ys
+ merge xs@(x ∷ xs₁) ys@(y ∷ ys₁) =
+ if x < y then x ∷ merge xs₁ ys
+ else y ∷ merge xs ys₁
+ ```
+
+* Idiom brackets.
+
+ There is new syntactic sugar for idiom brackets:
+
+ `(| e a1 .. an |)` expands to
+
+ `pure e <*> a1 <*> .. <*> an`
+
+ The desugaring takes place before scope checking and only requires names
+ `pure` and `_<*>_` in scope. Idiom brackets work well with operators, for
+ instance
+
+ `(| if a then b else c |)` desugars to
+
+ `pure if_then_else_ <*> a <*> b <*> c`
+
+ Limitations:
+
+ - The top-level application inside idiom brackets cannot include
+ implicit applications, so `(| foo {x = e} a b |)` is illegal. In
+ the case `e` is pure you can write `(| (foo {x = e}) a b |)`
+ which desugars to
+
+ `pure (foo {x = e}) <*> a <*> b`
+
+ - Binding syntax and operator sections cannot appear immediately inside
+ idiom brackets.
+
+* Layout for pattern matching lambdas.
+
+ You can now write pattern matching lambdas using the syntax
+
+ ```agda
+ λ where false → true
+ true → false
+ ```
+
+ avoiding the need for explicit curly braces and semicolons.
+
+* Overloaded projections
+ [Issue [#1944](https://github.com/agda/agda/issues/1944)].
+
+ Ambiguous projections are no longer a scope error. Instead they get
+ resolved based on the type of the record value they are
+ eliminating. This corresponds to constructors, which can be
+ overloaded and get disambiguated based on the type they are
+ introducing. Example:
+
+ ```agda
+ module _ (A : Set) (a : A) where
+
+ record R B : Set where
+ field f : B
+ open R public
+
+ record S B : Set where
+ field f : B
+ open S public
+ ```
+
+ Exporting `f` twice from both `R` and `S` is now allowed. Then,
+
+ ```agda
+ r : R A
+ f r = a
+
+ s : S A
+ f s = f r
+ ```
+
+ disambiguates to:
+
+ ```agda
+ r : R A
+ R.f r = a
+
+ s : S A
+ S.f s = R.f r
+ ```
+
+ If the type of the projection is known, it can also be disambiguated
+ unapplied.
+
+ ```agda
+ unapplied : R A -> A
+ unapplied = f
+ ```
+
+* Postfix projections
+ [Issue [#1963](https://github.com/agda/agda/issues/1963)].
+
+ Agda now supports a postfix syntax for projection application.
+ This style is more in harmony with copatterns. For example:
+
+ ```agda
+ record Stream (A : Set) : Set where
+ coinductive
+ field head : A
+ tail : Stream A
+
+ open Stream
+
+ repeat : ∀{A} (a : A) → Stream A
+ repeat a .head = a
+ repeat a .tail = repeat a
+
+ zipWith : ∀{A B C} (f : A → B → C) (s : Stream A) (t : Stream B) → Stream C
+ zipWith f s t .head = f (s .head) (t .head)
+ zipWith f s t .tail = zipWith f (s .tail) (t .tail)
+
+ module Fib (Nat : Set) (zero one : Nat) (plus : Nat → Nat → Nat) where
+
+ {-# TERMINATING #-}
+ fib : Stream Nat
+ fib .head = zero
+ fib .tail .head = one
+ fib .tail .tail = zipWith plus fib (fib .tail)
+ ```
+
+ The thing we eliminate with projection now is visibly the head,
+ i.e., the left-most expression of the sequence (e.g. `repeat` in
+ `repeat a .tail`).
+
+ The syntax overlaps with dot patterns, but for type correct left
+ hand sides there is no confusion: Dot patterns eliminate function
+ types, while (postfix) projection patterns eliminate record types.
+
+ By default, Agda prints system-generated projections (such as by
+ eta-expansion or case splitting) prefix. This can be changed with
+ the new option:
+
+ ```agda
+ {-# OPTIONS --postfix-projections #-}
+ ```
+
+ Result splitting in extended lambdas (aka pattern lambdas) always
+ produces postfix projections, as prefix projection pattern do not
+ work here: a prefix projection needs to go left of the head, but the
+ head is omitted in extended lambdas.
+
+ ```agda
+ dup : ∀{A : Set}(a : A) → A × A
+ dup = λ{ a → ? }
+ ```
+
+ Result splitting (`C-c C-c RET`) here will yield:
+
+ ```agda
+ dup = λ{ a .proj₁ → ? ; a .proj₂ → ? }
+ ```
+
+* Projection parameters
+ [Issue [#1954](https://github.com/agda/agda/issues/1954)].
+
+ When copying a module, projection parameters will now stay hidden
+ arguments, even if the module parameters are visible.
+ This matches the situation we had for constructors since long.
+ Example:
+
+ ```agda
+ module P (A : Set) where
+ record R : Set where
+ field f : A
+
+ open module Q A = P A
+ ```
+
+ Parameter `A` is now hidden in `R.f`:
+
+ ```agda
+ test : ∀{A} → R A → A
+ test r = R.f r
+ ```
+
+ Note that a module parameter that corresponds to the record value
+ argument of a projection will not be hidden.
+
+ ```agda
+ module M (A : Set) (r : R A) where
+ open R A r public
+
+ test' : ∀{A} → R A → A
+ test' r = M.f r
+ ```
+
+* Eager insertion of implicit arguments
+ [Issue [#2001](https://github.com/agda/agda/issues/2001)]
+
+ Implicit arguments are now (again) eagerly inserted in left-hand sides. The
+ previous behaviour of inserting implicits for where blocks, but not
+ right-hand sides was not type safe.
+
+* Module applications can now be eta expanded/contracted without
+ changing their behaviour
+ [Issue #[1985](https://github.com/agda/agda/issues/1985)]
+
+ Previously definitions exported using `open public` got the
+ incorrect type for underapplied module applications.
+
+ Example:
+
+ ```agda
+ module A where
+ postulate A : Set
+
+ module B (X : Set) where
+ open A public
+
+ module C₁ = B
+ module C₂ (X : Set) = B X
+ ```
+
+ Here both `C₁.A` and `C₂.A` have type `(X : Set) → Set`.
+
+* Polarity pragmas.
+
+ Polarity pragmas can be attached to postulates. The polarities express
+ how the postulate's arguments are used. The following polarities
+ are available:
+
+ `_`: Unused.
+
+ `++`: Strictly positive.
+
+ `+`: Positive.
+
+ `-`: Negative.
+
+ `*`: Unknown/mixed.
+
+ Polarity pragmas have the form
+
+ ```
+ {-# POLARITY name <zero or more polarities> #-}
+ ```
+
+ and can be given wherever fixity declarations can be given. The
+ listed polarities apply to the given postulate's arguments
+ (explicit/implicit/instance), from left to right. Polarities
+ currently cannot be given for module parameters. If the postulate
+ takes n arguments (excluding module parameters), then the number of
+ polarities given must be between 0 and n (inclusive).
+
+ Polarity pragmas make it possible to use postulated type formers in
+ recursive types in the following way:
+
+ ```agda
+ postulate
+ ∥_∥ : Set → Set
+
+ {-# POLARITY ∥_∥ ++ #-}
+
+ data D : Set where
+ c : ∥ D ∥ → D
+ ```
+
+ Note that one can use postulates that may seem benign, together with
+ polarity pragmas, to prove that the empty type is inhabited:
+
+ ```agda
+ postulate
+ _⇒_ : Set → Set → Set
+ lambda : {A B : Set} → (A → B) → A ⇒ B
+ apply : {A B : Set} → A ⇒ B → A → B
+
+ {-# POLARITY _⇒_ ++ #-}
+
+ data ⊥ : Set where
+
+ data D : Set where
+ c : D ⇒ ⊥ → D
+
+ not-inhabited : D → ⊥
+ not-inhabited (c f) = apply f (c f)
+
+ inhabited : D
+ inhabited = c (lambda not-inhabited)
+
+ bad : ⊥
+ bad = not-inhabited inhabited
+ ```
+
+ Polarity pragmas are not allowed in safe mode.
+
+* Declarations in a `where`-block are now
+ private. [Issue [#2101](https://github.com/agda/agda/issues/2101)]
+ This means that
+
+ ```agda
+ f ps = body where
+ decls
+ ```
+
+ is now equivalent to
+
+ ```agda
+ f ps = body where
+ private
+ decls
+ ```
+
+ This changes little, since the `decls` were anyway not in scope
+ outside `body`. However, it makes a difference for abstract
+ definitions, because private type signatures can see through
+ abstract definitions. Consider:
+
+ ```agda
+ record Wrap (A : Set) : Set where
+ field unwrap : A
+
+ postulate
+ P : ∀{A : Set} → A → Set
+
+ abstract
+
+ unnamedWhere : (A : Set) → Set
+ unnamedWhere A = A
+ where -- the following definitions are private!
+ B : Set
+ B = Wrap A
+
+ postulate
+ b : B
+ test : P (Wrap.unwrap b) -- succeeds
+ ```
+
+ The `abstract` is inherited in `where`-blocks from the parent (here:
+ function `unnamedWhere`). Thus, the definition of `B` is opaque and
+ the type equation `B = Wrap A` cannot be used to check type
+ signatures, not even of abstract definitions. Thus, checking the
+ type `P (Wrap.unwrap b)` would fail. However, if `test` is
+ private, abstract definitions are translucent in its type, and
+ checking succeeds. With the implemented change, all
+ `where`-definitions are private, in this case `B`, `b`, and `test`,
+ and the example succeeds.
+
+ Nothing changes for the named forms of `where`,
+
+ ```agda
+ module M where
+ module _ where
+ ```
+
+ For instance, this still fails:
+
+ ```agda
+ abstract
+
+ unnamedWhere : (A : Set) → Set
+ unnamedWhere A = A
+ module M where
+ B : Set
+ B = Wrap A
+
+ postulate
+ b : B
+ test : P (Wrap.unwrap b) -- fails
+ ```
+
+* Private anonymous modules now work as expected
+ [Issue [#2199](https://github.com/agda/agda/issues/2199)]
+
+ Previously the `private` was ignored for anonymous modules causing
+ its definitions to be visible outside the module containing the
+ anonymous module. This is no longer the case. For instance,
+
+ ```agda
+ module M where
+ private
+ module _ (A : Set) where
+ Id : Set
+ Id = A
+
+ foo : Set → Set
+ foo = Id
+
+ open M
+
+ bar : Set → Set
+ bar = Id -- Id is no longer in scope here
+ ```
+
+* Pattern synonyms are now expanded on left hand sides of DISPLAY
+ pragmas [Issue [#2132](https://github.com/agda/agda/issues/2132)].
+ Example:
+
+ ```agda
+ data D : Set where
+ C c : D
+ g : D → D
+
+ pattern C′ = C
+
+ {-# DISPLAY C′ = C′ #-}
+ {-# DISPLAY g C′ = c #-}
+ ```
+
+ This now behaves as:
+
+ ```agda
+ {-# DISPLAY C = C′ #-}
+ {-# DISPLAY g C = c #-}
+ ```
+
+ Expected error for
+
+ ```agda
+ test : C ≡ g C
+ test = refl
+ ```
+
+ is thus:
+
+ ```
+ C′ != c of type D
+ ```
+
+* The built-in floats have new semantics to fix inconsistencies
+ and to improve cross-platform portability.
+
+ - Float equality has been split into two primitives.
+ ``primFloatEquality`` is designed to establish
+ decidable propositional equality while
+ ``primFloatNumericalEquality`` is intended for numerical
+ computations. They behave as follows:
+
+ ```
+ primFloatEquality NaN NaN = True
+ primFloatEquality 0.0 -0.0 = False
+
+ primFloatNumericalEquality NaN NaN = False
+ primFloatNumericalEquality 0.0 -0.0 = True
+ ```
+
+ This change fixes an inconsistency, see [Issue [#2169](https://github.com/agda/agda/issues/2169)].
+ For further detail see the [user manual](http://agda.readthedocs.io/en/latest/language/built-ins.html#floats).
+
+ - Floats now have only one `NaN` value. This is necessary
+ for proper Float support in the JavaScript backend,
+ as JavaScript (and some other platforms) only support
+ one `NaN` value.
+
+ - The primitive function `primFloatLess` was renamed
+ `primFloatNumericalLess`.
+
+* Added new primitives to built-in floats:
+
+ - `primFloatNegate : Float → Float`
+ [Issue [#2194](https://github.com/agda/agda/issues/2194)]
+
+ - Trigonometric primitives
+ [Issue [#2200](https://github.com/agda/agda/issues/2200)]:
+
+ ```agda
+ primCos : Float → Float
+ primTan : Float → Float
+ primASin : Float → Float
+ primACos : Float → Float
+ primATan : Float → Float
+ primATan2 : Float → Float → Float
+ ```
+
+* Anonymous declarations
+ [Issue [#1465](https://github.com/agda/agda/issues/1465)].
+
+ A module can contain an arbitrary number of declarations
+ named `_` which will scoped-checked and type-checked but
+ won't be made available in the scope (nor exported). They
+ cannot introduce arguments on the LHS (but one can use
+ lambda-abstractions on the RHS) and they cannot be defined
+ by recursion.
+
+ ```agda
+ _ : Set → Set
+ _ = λ x → x
+ ```
+
+### Rewriting
+
+* The REWRITE pragma can now handle several names. E.g.:
+ ```agda
+ {-# REWRITE eq1 eq2 #-}
+ ```
+
+### Reflection
+
+* You can now use macros in reflected terms
+ [Issue [#2130](https://github.com/agda/agda/issues/2130)].
+
+ For instance, given a macro
+
+ ```agda
+ macro
+ some-tactic : Term → TC ⊤
+ some-tactic = ...
+ ```
+
+ the term `def (quote some-tactic) []` represents a call to the
+ macro. This makes it a lot easier to compose tactics.
+
+* The reflection machinery now uses normalisation less often:
+
+ * Macros no longer normalise the (automatically quoted) term
+ arguments.
+
+ * The TC primitives `inferType`, `checkType` and `quoteTC` no longer
+ normalise their arguments.
+
+ * The following deprecated constructions may also have been changed:
+ `quoteGoal`, `quoteTerm`, `quoteContext` and `tactic`.
+
+* New TC primitive: `withNormalisation`.
+
+ To recover the old normalising behaviour of `inferType`, `checkType`,
+ `quoteTC` and `getContext`, you can wrap them inside a call to
+ `withNormalisation true`:
+
+ ```agda
+ withNormalisation : ∀ {a} {A : Set a} → Bool → TC A → TC A
+ ```
+
+* New TC primitive: `reduce`.
+
+ ```agda
+ reduce : Term → TC Term
+ ```
+
+ Reduces its argument to weak head normal form.
+
+* Added new TC primitive: `isMacro`
+ [Issue [#2182](https://github.com/agda/agda/issues/2182)]
+
+ ```agda
+ isMacro : Name → TC Bool
+ ```
+
+ Returns `true` if the name refers to a macro, otherwise `false`.
+
+Type checking
+-------------
+
+* Files with open metas can be imported now
+ [Issue [#964](https://github.com/agda/agda/issues/964)]. This
+ should make simultaneous interactive development on several modules
+ more pleasant.
+
+ Requires option: `--allow-unsolved-metas`
+
+ Internally, before serialization, open metas are turned into postulates named
+
+ ```
+ unsolved#meta.<nnn>
+ ```
+
+ where `<nnn>` is the internal meta variable number.
+
+* The performance of the compile-time evaluator has been greatly improved.
+
+ - Fixed a memory leak in evaluator
+ (Issue [#2147](https://github.com/agda/agda/issues/2147)).
+
+ - Reduction speed improved by an order of magnitude and is now
+ comparable to the performance of GHCi. Still call-by-name though.
+
+* The detection of types that satisfy K added in Agda 2.5.1 has been
+ rolled back (see
+ Issue [#2003](https://github.com/agda/agda/issues/2003)).
+
+* Eta-equality for record types is now only on after the positivity
+ checker has confirmed it is safe to have it. Eta-equality for
+ unguarded inductive records previously lead to looping of the type
+ checker.
+ [See Issue [#2197](https://github.com/agda/agda/issues/2197)]
+
+ ```agda
+ record R : Set where
+ inductive
+ field r : R
+
+ loops : R
+ loops = ?
+ ```
+
+ As a consequence of this change, the following example does not
+ type-check any more:
+
+ ```agda
+ mutual
+ record ⊤ : Set where
+
+ test : ∀ {x y : ⊤} → x ≡ y
+ test = refl
+ ```
+
+ It fails because the positivity checker is only run after the mutual
+ block, thus, eta-equality for `⊤` is not available when checking
+ test.
+
+ One can declare eta-equality explicitly, though, to make this
+ example work.
+
+ ```agda
+ mutual
+ record ⊤ : Set where
+ eta-equality
+
+ test : ∀ {x y : ⊤} → x ≡ y
+ test = refl
+ ```
+
+* Records with instance fields are now eta expanded before instance search.
+
+ For instance, assuming `Eq` and `Ord` with boolean functions `_==_` and `_<_`
+ respectively,
+
+ ```agda
+ record EqAndOrd (A : Set) : Set where
+ field {{eq}} : Eq A
+ {{ord}} : Ord A
+
+
+ leq : {A : Set} {{_ : EqAndOrd A}} → A → A → Bool
+ leq x y = x == y || x < y
+ ```
+
+ Here the `EqAndOrd` record is automatically unpacked before instance search,
+ revealing the component `Eq` and `Ord` instances.
+
+ This can be used to simulate superclass dependencies.
+
+* Overlappable record instance fields.
+
+ Instance fields in records can be marked as overlappable using the new
+ `overlap` keyword:
+
+ ```agda
+ record Ord (A : Set) : Set where
+ field
+ _<_ : A → A → Bool
+ overlap {{eqA}} : Eq A
+ ```
+
+ When instance search finds multiple candidates for a given instance goal and
+ they are **all** overlappable it will pick the left-most candidate instead of
+ refusing to solve the instance goal.
+
+ This can be use to solve the problem arising from shared "superclass"
+ dependencies. For instance, if you have, in addition to `Ord` above, a `Num`
+ record that also has an `Eq` field and want to write a function requiring
+ both `Ord` and `Num`, any `Eq` constraint will be solved by the `Eq` instance
+ from whichever argument that comes first.
+
+ ```agda
+ record Num (A : Set) : Set where
+ field
+ fromNat : Nat → A
+ overlap {{eqA}} : Eq A
+
+ lessOrEqualFive : {A : Set} {{NumA : Num A}} {{OrdA : Ord A}} → A → Bool
+ lessOrEqualFive x = x == fromNat 5 || x < fromNat 5
+ ```
+
+ In this example the call to `_==_` will use the `eqA` field from `NumA`
+ rather than the one from `OrdA`. Note that these may well be different.
+
+* Instance fields can be left out of copattern matches
+ [Issue [#2288](https://github.com/agda/agda/issues/2288)]
+
+ Missing cases for instance fields (marked `{{` `}}`) in copattern matches
+ will be solved using instance search. This makes defining instances with
+ superclass fields much nicer. For instance, we can define `Nat` instances of
+ `Eq`, `Ord` and `Num` from above as follows:
+
+ ```agda
+ instance
+ EqNat : Eq Nat
+ _==_ {{EqNat}} n m = eqNat n m
+
+ OrdNat : Ord Nat
+ _<_ {{OrdNat}} n m = lessNat n m
+
+ NumNat : Num Nat
+ fromNat {{NumNat}} n = n
+ ```
+
+ The `eqA` fields of `Ord` and `Num` are filled in using instance search (with
+ `EqNat` in this case).
+
+* Limited instance search depth
+ [Issue [#2269](https://github.com/agda/agda/issues/2269)]
+
+ To prevent instance search from looping on bad instances
+ (see [Issue #1743](https://github.com/agda/agda/issues/1743)) the search
+ depth of instance search is now limited. The maximum depth can be set with
+ the `--instance-search-depth` flag and the default value is `500`.
+
+Emacs mode
+----------
+
+* New command `C-u C-u C-c C-n`: Use `show` to display the result of
+ normalisation.
+
+ Calling `C-u C-u C-c C-n` on an expression `e` (in a hole or at top level)
+ normalises `show e` and prints the resulting string, or an error message if
+ the expression does not normalise to a literal string.
+
+ This is useful when working with complex data structures for which you have
+ defined a nice `Show` instance.
+
+ Note that the name `show` is hardwired into the command.
+
+* Changed feature: Interactively split result.
+
+ Make-case (`C-c C-c`) with no variables will now *either* introduce
+ function arguments *or* do a copattern split (or fail).
+
+ This is as before:
+
+ ```agda
+ test : {A B : Set} (a : A) (b : B) → A × B
+ test a b = ?
+
+ -- expected:
+ -- proj₁ (test a b) = {!!}
+ -- proj₂ (test a b) = {!!}
+
+ testFun : {A B : Set} (a : A) (b : B) → A × B
+ testFun = ?
+
+ -- expected:
+ -- testFun a b = {!!}
+ ```
+
+ This is has changed:
+
+ ```agda
+ record FunRec A : Set where
+ field funField : A → A
+ open FunRec
+
+ testFunRec : ∀{A} → FunRec A
+ testFunRec = ?
+
+ -- expected (since 2016-05-03):
+ -- funField testFunRec = {!!}
+
+ -- used to be:
+ -- funField testFunRec x = {!!}
+ ```
+
+* Changed feature: Split on hidden variables.
+
+ Make-case (`C-c C-c`) will no longer split on the given hidden
+ variables, but only make them visible. (Splitting can then be
+ performed in a second go.)
+
+ ```agda
+ test : ∀{N M : Nat} → Nat → Nat → Nat
+ test N M = {!.N N .M!}
+ ```
+
+ Invoking splitting will result in:
+
+ ```agda
+ test {N} {M} zero M₁ = ?
+ test {N} {M} (suc N₁) M₁ = ?
+ ```
+
+ The hidden `.N` and `.M` have been brought into scope, the
+ visible `N` has been split upon.
+
+* Non-fatal errors/warnings.
+
+ Non-fatal errors and warnings are now displayed in the info buffer
+ and do not interrupt the typechecking of the file.
+
+ Currently termination errors, unsolved metavariables, unsolved
+ constraints, positivity errors, deprecated BUILTINs, and empty
+ REWRITING pragmas are non-fatal errors.
+
+* Highlighting for positivity check failures
+
+ Negative occurences of a datatype in its definition are now
+ highlighted in a way similar to termination errors.
+
+* The abbrev for codata was replaced by an abbrev for code
+ environments.
+
+ If you type `c C-x '` (on a suitably standard setup), then Emacs
+ will insert the following text:
+
+ ```agda
+ \begin{code}<newline> <cursor><newline>\end{code}<newline>.
+ ```
+
+* The LaTeX backend can now be invoked from the Emacs mode.
+
+ Using the compilation command (`C-c C-x C-c`).
+
+ The flag `--latex-dir` can be used to set the output directory (by
+ default: `latex`). Note that if this directory is a relative path,
+ then it is interpreted relative to the "project root". (When the
+ LaTeX backend is invoked from the command line the path is
+ interpreted relative to the current working directory.) Example: If
+ the module `A.B.C` is located in the file `/foo/A/B/C.agda`, then
+ the project root is `/foo/`, and the default output directory is
+ `/foo/latex/`.
+
+* The compilation command (`C-c C-x C-c`) now by default asks for a
+ backend.
+
+ To avoid this question, set the customisation variable
+ `agda2-backend` to an appropriate value.
+
+* The command `agda2-measure-load-time` no longer "touches" the file,
+ and the optional argument `DONT-TOUCH` has been removed.
+
+* New command `C-u (C-u) C-c C-s`: Simplify or normalise the solution `C-c C-s` produces
+
+ When writing examples, it is nice to have the hole filled in with
+ a normalised version of the solution. Calling `C-c C-s` on
+
+ ```agda
+ _ : reverse (0 ∷ 1 ∷ []) ≡ ?
+ _ = refl
+ ```
+
+ used to yield the non informative `reverse (0 ∷ 1 ∷ [])` when we would
+ have hopped to get `1 ∷ 0 ∷ []` instead. We can now control finely the
+ degree to which the solution is simplified.
+
+* Changed feature: Solving the hole at point
+
+ Calling `C-c C-s` inside a specific goal does not solve *all* the goals
+ already instantiated internally anymore: it only solves the one at hand
+ (if possible).
+
+* New bindings: All the blackboard bold letters are now available
+ [Pull Request [#2305](https://github.com/agda/agda/pull/2305)]
+
+ The Agda input method only bound a handful of the blackboard bold letters
+ but programmers were actually using more than these. They are now all
+ available: lowercase and uppercase. Some previous bindings had to be
+ modified for consistency. The naming scheme is as follows:
+
+ * \bx for lowercase blackboard bold
+ * \bX for uppercase blackboard bold
+ * \bGx for lowercase greek blackboard bold (similar to \Gx for greeks)
+ * \bGX for uppercase greek blackboard bold (similar to \GX for uppercase greeks)
+
+* Replaced binding for go back
+
+ Use `M-,` (instead of `M-*`) for go back in Emacs ≥ 25.1 (and
+ continue using `M-*` with previous versions of Emacs).
+
+Compiler backends
+-----------------
+
+* JS compiler backend
+
+ The JavaScript backend has been (partially) rewritten. The
+ JavaScript backend now supports most Agda features, notably
+ copatterns can now be compiled to JavaScript. Furthermore, the
+ existing optimizations from the other backends now apply to the
+ JavaScript backend as well.
+
+* GHC, JS and UHC compiler backends
+
+ Added new primitives to built-in floats
+ [Issues [#2194](https://github.com/agda/agda/issues/2194) and
+ [#2200](https://github.com/agda/agda/issues/2200)]:
+
+ ```agda
+ primFloatNegate : Float → Float
+ primCos : Float → Float
+ primTan : Float → Float
+ primASin : Float → Float
+ primACos : Float → Float
+ primATan : Float → Float
+ primATan2 : Float → Float → Float
+ ```
+
+LaTeX backend
+-------------
+
+* Code blocks are now (by default) surrounded by vertical space.
+ [Issue [#2198](https://github.com/agda/agda/issues/2198)]
+
+ Use `\AgdaNoSpaceAroundCode{}` to avoid this vertical space, and
+ `\AgdaSpaceAroundCode{}` to reenable it.
+
+ Note that, if `\AgdaNoSpaceAroundCode{}` is used, then empty lines
+ before or after a code block will not necessarily lead to empty
+ lines in the generated document. However, empty lines *inside* the
+ code block do (by default) lead to empty lines in the output.
+
+ If you prefer the previous behaviour, then you can use the `agda.sty`
+ file that came with the previous version of Agda.
+
+* `\AgdaHide{...}` now eats trailing spaces (using `\ignorespaces`).
+
+* New environments: `AgdaAlign`, `AgdaSuppressSpace` and
+ `AgdaMultiCode`.
+
+ Sometimes one might want to break up a code block into multiple
+ pieces, but keep code in different blocks aligned with respect to
+ each other. Then one can use the `AgdaAlign` environment. Example
+ usage:
+ ```latex
+ \begin{AgdaAlign}
+ \begin{code}
+ code
+ code (more code)
+ \end{code}
+ Explanation...
+ \begin{code}
+ aligned with "code"
+ code (aligned with (more code))
+ \end{code}
+ \end{AgdaAlign}
+ ```
+ Note that `AgdaAlign` environments should not be nested.
+
+ Sometimes one might also want to hide code in the middle of a code
+ block. This can be accomplished in the following way:
+ ```latex
+ \begin{AgdaAlign}
+ \begin{code}
+ visible
+ \end{code}
+ \AgdaHide{
+ \begin{code}
+ hidden
+ \end{code}}
+ \begin{code}
+ visible
+ \end{code}
+ \end{AgdaAlign}
+ ```
+ However, the result may be ugly: extra space is perhaps inserted
+ around the code blocks.
+
+ The `AgdaSuppressSpace` environment ensures that extra space is only
+ inserted before the first code block, and after the last one (but
+ not if `\AgdaNoSpaceAroundCode{}` is used).
+
+ The environment takes one argument, the number of wrapped code
+ blocks (excluding hidden ones). Example usage:
+ ```latex
+ \begin{AgdaAlign}
+ \begin{code}
+ code
+ more code
+ \end{code}
+ Explanation...
+ \begin{AgdaSuppressSpace}{2}
+ \begin{code}
+ aligned with "code"
+ aligned with "more code"
+ \end{code}
+ \AgdaHide{
+ \begin{code}
+ hidden code
+ \end{code}}
+ \begin{code}
+ also aligned with "more code"
+ \end{code}
+ \end{AgdaSuppressSpace}
+ \end{AgdaAlign}
+ ```
+
+ Note that `AgdaSuppressSpace` environments should not be nested.
+
+ There is also a combined environment, `AgdaMultiCode`, that combines
+ the effects of `AgdaAlign` and `AgdaSuppressSpace`.
+
+Tools
+-----
+
+### agda-ghc-names
+
+The `agda-ghc-names` now has its own repository at
+
+ https://github.com/agda/agda-ghc-names
+
+and is no longer distributed with Agda.
+
+Release notes for Agda version 2.5.1.2
+======================================
+
+* Fixed broken type signatures that were incorrectly accepted due to
+ [GHC #12784](https://ghc.haskell.org/trac/ghc/ticket/12784).
+
+Release notes for Agda version 2.5.1.1
+======================================
+
+Installation and infrastructure
+-------------------------------
+
+* Added support for GHC 8.0.1.
+
+* Documentation is now built with Python >=3.3, as done by
+ [readthedocs.org](https://readthedocs.org/).
+
+Bug fixes
+---------
+
+* Fixed a serious performance problem with instance search
+
+ Issues [#1952](https://github.com/agda/agda/issues/1952) and
+ [#1998](https://github.com/agda/agda/issues/1998). Also related:
+ [#1955](https://github.com/agda/agda/issues/1955) and
+ [#2025](https://github.com/agda/agda/issues/2025)
+
+* Interactively splitting variable with `C-c C-c` no longer introduces
+ new trailing patterns. This fixes
+ Issue [#1950](https://github.com/agda/agda/issues/1950).
+
+ ```agda
+ data Ty : Set where
+ _⇒_ : Ty → Ty → Ty
+
+ ⟦_⟧ : Ty → Set
+ ⟦ A ⇒ B ⟧ = ⟦ A ⟧ → ⟦ B ⟧
+
+ data Term : Ty → Set where
+ K : (A B : Ty) → Term (A ⇒ (B ⇒ A))
+
+ test : (A : Ty) (a : Term A) → ⟦ A ⟧
+ test A a = {!a!}
+ ```
+
+ Before change, case splitting on `a` would give
+
+ ```agda
+ test .(A ⇒ (B ⇒ A)) (K A B) x x₁ = ?
+ ```
+
+ Now, it yields
+
+ ```agda
+ test .(A ⇒ (B ⇒ A)) (K A B) = ?
+ ```
+
+* In literate TeX files, `\begin{code}` and `\end{code}` can be
+ preceded (resp. followed) by TeX code on the same line. This fixes
+ Issue [#2077](https://github.com/agda/agda/issues/2077).
+
+* Other issues fixed (see
+ [bug tracker](https://github.com/agda/agda/issues)):
+
+ [#1951](https://github.com/agda/agda/issues/1951) (mixfix binders
+ not working in 'syntax')
+
+ [#1967](https://github.com/agda/agda/issues/1967) (too eager
+ insteance search error)
+
+ [#1974](https://github.com/agda/agda/issues/1974) (lost constraint
+ dependencies)
+
+ [#1982](https://github.com/agda/agda/issues/1982) (internal error in
+ unifier)
+
+ [#2034](https://github.com/agda/agda/issues/2034) (function type
+ instance goals)
+
+Compiler backends
+-----------------
+
+* UHC compiler backend
+
+ Added support for UHC 1.1.9.4.
+
+Release notes for Agda version 2.5.1
+====================================
+
+Documentation
+-------------
+
+* There is now an official Agda User Manual:
+ http://agda.readthedocs.org/en/stable/
+
+Installation and infrastructure
+-------------------------------
+
+* Builtins and primitives are now defined in a new set of modules available to
+ all users, independent of any particular library. The modules are
+
+ ```agda
+ Agda.Builtin.Bool
+ Agda.Builtin.Char
+ Agda.Builtin.Coinduction
+ Agda.Builtin.Equality
+ Agda.Builtin.Float
+ Agda.Builtin.FromNat
+ Agda.Builtin.FromNeg
+ Agda.Builtin.FromString
+ Agda.Builtin.IO
+ Agda.Builtin.Int
+ Agda.Builtin.List
+ Agda.Builtin.Nat
+ Agda.Builtin.Reflection
+ Agda.Builtin.Size
+ Agda.Builtin.Strict
+ Agda.Builtin.String
+ Agda.Builtin.TrustMe
+ Agda.Builtin.Unit
+ ```
+
+ The standard library reexports the primitives from the new modules.
+
+ The `Agda.Builtin` modules are installed in the same way as
+ `Agda.Primitive`, but unlike `Agda.Primitive` they are not loaded
+ automatically.
+
+Pragmas and options
+-------------------
+
+* Library management
+
+ There is a new 'library' concept for managing include paths. A library
+ consists of
+ - a name,
+ - a set of libraries it depends on, and
+ - a set of include paths.
+
+ A library is defined in a `.agda-lib` file using the following
+ format:
+
+ ```
+ name: LIBRARY-NAME -- Comment
+ depend: LIB1 LIB2
+ LIB3
+ LIB4
+ include: PATH1
+ PATH2
+ PATH3
+ ```
+
+ Dependencies are library names, not paths to `.agda-lib` files, and
+ include paths are relative to the location of the library-file.
+
+ To be useable, a library file has to be listed (with its full path)
+ in `AGDA_DIR/libraries` (or `AGDA_DIR/libraries-VERSION`, for a
+ given Agda version). `AGDA_DIR` defaults to `~/.agda` on Unix-like
+ systems and `C:/Users/USERNAME/AppData/Roaming/agda` or similar on
+ Windows, and can be overridden by setting the `AGDA_DIR` environment
+ variable.
+
+ Environment variables in the paths (of the form `$VAR` or `${VAR}`)
+ are expanded. The location of the libraries file used can be
+ overridden using the `--library-file=FILE` flag, although this is
+ not expected to be very useful.
+
+ You can find out the precise location of the 'libraries' file by
+ calling `agda -l fjdsk Dummy.agda` and looking at the error message
+ (assuming you don't have a library called fjdsk installed).
+
+ There are three ways a library gets used:
+
+ - You supply the `--library=LIB` (or `-l LIB`) option to
+ Agda. This is equivalent to adding a `-iPATH` for each of the
+ include paths of `LIB` and its (transitive) dependencies.
+
+ - No explicit `--library` flag is given, and the current project
+ root (of the Agda file that is being loaded) or one of its
+ parent directories contains a `.agda-lib` file defining a
+ library `LIB`. This library is used as if a `--librarary=LIB`
+ option had been given, except that it is not necessary for the
+ library to be listed in the `AGDA_DIR/libraries` file.
+
+ - No explicit `--library` flag, and no `.agda-lib` file in the
+ project root. In this case the file `AGDA_DIR/defaults` is read
+ and all libraries listed are added to the path. The defaults
+ file should contain a list of library names, each on a separate
+ line. In this case the current directory is also added to the
+ path.
+
+ To disable default libraries, you can give the flag
+ `--no-default-libraries`.
+
+ Library names can end with a version number (for instance,
+ `mylib-1.2.3`). When resolving a library name (given in a `--library`
+ flag, or listed as a default library or library dependency) the
+ following rules are followed:
+
+ - If you don't give a version number, any version will do.
+
+ - If you give a version number an exact match is required.
+
+ - When there are multiple matches an exact match is preferred, and
+ otherwise the latest matching version is chosen.
+
+ For example, suppose you have the following libraries installed:
+ `mylib`, `mylib-1.0`, `otherlib-2.1`, and `otherlib-2.3`. In this
+ case, aside from the exact matches you can also say
+ `--library=otherlib` to get `otherlib-2.3`.
+
+* New Pragma `COMPILED_DECLARE_DATA` for binding recursively defined
+ Haskell data types to recursively defined Agda data types.
+
+ If you have a Haskell type like
+
+ ```haskell
+ {-# LANGUAGE GADTs #-}
+
+ module Issue223 where
+
+ data A where
+ BA :: B -> A
+
+ data B where
+ AB :: A -> B
+ BB :: B
+ ```
+
+ You can now bind it to corresponding mutual Agda inductive data
+ types as follows:
+
+ ```agda
+ {-# IMPORT Issue223 #-}
+
+ data A : Set
+ {-# COMPILED_DECLARE_DATA A Issue223.A #-}
+ data B : Set
+ {-# COMPILED_DECLARE_DATA B Issue223.B #-}
+
+ data A where
+ BA : B → A
+
+ {-# COMPILED_DATA A Issue223.A Issue223.BA #-}
+ data B where
+ AB : A → B
+ BB : B
+
+ {-# COMPILED_DATA B Issue223.B Issue223.AB Issue223.BB #-}
+ ```
+
+ This fixes Issue [#223](https://github.com/agda/agda/issues/223).
+
+* New pragma `HASKELL` for adding inline Haskell code (GHC backend only)
+
+ Arbitrary Haskell code can be added to a module using the `HASKELL`
+ pragma. For instance,
+
+ ```agda
+ {-# HASKELL
+ echo :: IO ()
+ echo = getLine >>= putStrLn
+ #-}
+
+ postulate echo : IO ⊤
+ {-# COMPILED echo echo #-}
+ ```
+
+* New option `--exact-split`.
+
+ The `--exact-split` flag causes Agda to raise an error whenever a
+ clause in a definition by pattern matching cannot be made to hold
+ definitionally (i.e. as a reduction rule). Specific clauses can be
+ excluded from this check by means of the `{-# CATCHALL #-}` pragma.
+
+ For instance, the following definition will be rejected as the second clause
+ cannot be made to hold definitionally:
+
+ ```agda
+ min : Nat → Nat → Nat
+ min zero y = zero
+ min x zero = zero
+ min (suc x) (suc y) = suc (min x y
+ ```
+
+ Catchall clauses have to be marked as such, for instance:
+
+ ```agda
+ eq : Nat → Nat → Bool
+ eq zero zero = true
+ eq (suc m) (suc n) = eq m n
+ {-# CATCHALL #-}
+ eq _ _ = false
+ ```
+
+* New option: `--no-exact-split`.
+
+ This option can be used to override a global `--exact-split` in a
+ file, by adding a pragma `{-# OPTIONS --no-exact-split #-}`.
+
+* New options: `--sharing` and `--no-sharing`.
+
+ These options are used to enable/disable sharing and call-by-need
+ evaluation. The default is `--no-sharing`.
+
+ Note that they cannot appear in an OPTIONS pragma, but have to be
+ given as command line arguments or added to the Agda Program Args
+ from Emacs with `M-x customize-group agda2`.
+
+* New pragma `DISPLAY`.
+
+ ```agda
+ {-# DISPLAY f e1 .. en = e #-}
+ ```
+
+ This causes `f e1 .. en` to be printed in the same way as `e`, where
+ `ei` can bind variables used in `e`. The expressions `ei` and `e`
+ are scope checked, but not type checked.
+
+ For example this can be used to print overloaded (instance) functions with
+ the overloaded name:
+
+ ```agda
+ instance
+ NumNat : Num Nat
+ NumNat = record { ..; _+_ = natPlus }
+
+ {-# DISPLAY natPlus a b = a + b #-}
+ ```
+
+ Limitations
+
+ - Left-hand sides are restricted to variables, constructors, defined
+ functions or types, and literals. In particular, lambdas are not
+ allowed in left-hand sides.
+
+ - Since `DISPLAY` pragmas are not type checked implicit argument
+ insertion may not work properly if the type of `f` computes to an
+ implicit function space after pattern matching.
+
+* Removed pragma `{-# ETA R #-}`
+
+ The pragma `{-# ETA R #-}` is replaced by the `eta-equality` directive
+ inside record declarations.
+
+* New option `--no-eta-equality`.
+
+ The `--no-eta-equality` flag disables eta rules for declared record
+ types. It has the same effect as `no-eta-equality` inside each
+ declaration of a record type `R`.
+
+ If used with the OPTIONS pragma it will not affect records defined
+ in other modules.
+
+* The semantics of `{-# REWRITE r #-}` pragmas in parametrized modules
+ has changed (see
+ Issue [#1652](https://github.com/agda/agda/issues/1652)).
+
+ Rewrite rules are no longer lifted to the top context. Instead, they
+ now only apply to terms in (extensions of) the module context. If
+ you want the old behaviour, you should put the `{-# REWRITE r #-}`
+ pragma outside of the module (i.e. unindent it).
+
+* New pragma `{-# INLINE f #-}` causes `f` to be inlined during
+ compilation.
+
+* The `STATIC` pragma is now taken into account during compilation.
+
+ Calls to a function marked `STATIC` are normalised before
+ compilation. The typical use case for this is to mark the
+ interpreter of an embedded language as `STATIC`.
+
+* Option `--type-in-type` no longer implies
+ `--no-universe-polymorphism`, thus, it can be used with explicit
+ universe
+ levels. [Issue [#1764](https://github.com/agda/agda/issues/1764)] It
+ simply turns off error reporting for any level mismatch now.
+ Examples:
+
+ ```agda
+ {-# OPTIONS --type-in-type #-}
+
+ Type : Set
+ Type = Set
+
+ data D {α} (A : Set α) : Set where
+ d : A → D A
+
+ data E α β : Set β where
+ e : Set α → E α β
+ ```
+
+* New `NO_POSITIVITY_CHECK` pragma to switch off the positivity checker
+ for data/record definitions and mutual blocks.
+
+ The pragma must precede a data/record definition or a mutual block.
+
+ The pragma cannot be used in `--safe` mode.
+
+ Examples (see `Issue1614*.agda` and `Issue1760*.agda` in
+ `test/Succeed/`):
+
+ 1. Skipping a single data definition.
+
+ ```agda
+ {-# NO_POSITIVITY_CHECK #-}
+ data D : Set where
+ lam : (D → D) → D
+ ```
+
+ 2. Skipping a single record definition.
+
+ ```agda
+ {-# NO_POSITIVITY_CHECK #-}
+ record U : Set where
+ field ap : U → U
+ ```
+
+ 3. Skipping an old-style mutual block: Somewhere within a `mutual`
+ block before a data/record definition.
+
+ ```agda
+ mutual
+ data D : Set where
+ lam : (D → D) → D
+
+ {-# NO_POSITIVITY_CHECK #-}
+ record U : Set where
+ field ap : U → U
+ ```
+
+ 4. Skipping an old-style mutual block: Before the `mutual` keyword.
+
+ ```agda
+ {-# NO_POSITIVITY_CHECK #-}
+ mutual
+ data D : Set where
+ lam : (D → D) → D
+
+ record U : Set where
+ field ap : U → U
+ ```
+
+ 5. Skipping a new-style mutual block: Anywhere before the
+ declaration or the definition of data/record in the block.
+
+ ```agda
+ record U : Set
+ data D : Set
+
+ record U where
+ field ap : U → U
+
+ {-# NO_POSITIVITY_CHECK #-}
+ data D where
+ lam : (D → D) → D
+ ```
+
+* Removed `--no-coverage-check`
+ option. [Issue [#1918](https://github.com/agda/agda/issues/1918)]
+
+Language
+--------
+
+### Operator syntax
+
+* The default fixity for syntax declarations has changed from -666 to 20.
+
+* Sections.
+
+ Operators can be sectioned by replacing arguments with underscores.
+ There must not be any whitespace between these underscores and the
+ adjacent nameparts. Examples:
+
+ ```agda
+ pred : ℕ → ℕ
+ pred = _∸ 1
+
+ T : Bool → Set
+ T = if_then ⊤ else ⊥
+
+ if : {A : Set} (b : Bool) → A → A → A
+ if b = if b then_else_
+ ```
+
+ Sections are translated into lambda expressions. Examples:
+
+ ```agda
+ _∸ 1 ↦ λ section → section ∸ 1
+
+ if_then ⊤ else ⊥ ↦ λ section → if section then ⊤ else ⊥
+
+ if b then_else_ ↦ λ section section₁ →
+ if b then section else section₁
+ ```
+
+ Operator sections have the same fixity as the underlying operator
+ (except in cases like `if b then_else_`, in which the section is
+ "closed", but the operator is not).
+
+ Operator sections are not supported in patterns (with the exception
+ of dot patterns), and notations coming from syntax declarations
+ cannot be sectioned.
+
+* A long-standing operator fixity bug has been fixed. As a consequence
+ some programs that used to parse no longer do.
+
+ Previously each precedence level was (incorrectly) split up into
+ five separate ones, ordered as follows, with the earlier ones
+ binding less tightly than the later ones:
+
+ - Non-associative operators.
+
+ - Left associative operators.
+
+ - Right associative operators.
+
+ - Prefix operators.
+
+ - Postfix operators.
+
+ Now this problem has been addressed. It is no longer possible to mix
+ operators of a given precedence level but different associativity.
+ However, prefix and right associative operators are seen as having
+ the same associativity, and similarly for postfix and left
+ associative operators.
+
+ Examples
+ --------
+
+ The following code is no longer accepted:
+
+ ```agda
+ infixl 6 _+_
+ infix 6 _∸_
+
+ rejected : ℕ
+ rejected = 1 + 0 ∸ 1
+ ```
+
+ However, the following previously rejected code is accepted:
+
+ ```agda
+ infixr 4 _,_
+ infix 4 ,_
+
+ ,_ : {A : Set} {B : A → Set} {x : A} → B x → Σ A B
+ , y = _ , y
+
+ accepted : Σ ℕ λ i → Σ ℕ λ j → Σ (i ≡ j) λ _ → Σ ℕ λ k → j ≡ k
+ accepted = 5 , , refl , , refl
+ ```
+
+* The classification of notations with binders into the categories
+ infix, prefix, postfix or closed has
+ changed. [Issue [#1450](https://github.com/agda/agda/issues/1450)]
+
+ The difference is that, when classifying the notation, only
+ *regular* holes are taken into account, not *binding* ones.
+
+ Example: The notation
+
+ ```agda
+ syntax m >>= (λ x → f) = x <- m , f
+ ```
+
+ was previously treated as infix, but is now treated as prefix.
+
+* Notation can now include wildcard binders.
+
+ Example: `syntax Σ A (λ _ → B) = A × B`
+
+* If an overloaded operator is in scope with several distinct
+ precedence levels, then several instances of this operator will be
+ included in the operator grammar, possibly leading to ambiguity.
+ Previously the operator was given the default fixity
+ [Issue [#1436](https://github.com/agda/agda/issues/1436)].
+
+ There is an exception to this rule: If there are multiple precedences,
+ but at most one is explicitly declared, then only one instance will be
+ included in the grammar. If there are no explicitly declared
+ precedences, then this instance will get the default precedence, and
+ otherwise it will get the declared precedence.
+
+ If multiple occurrences of an operator are "merged" in the grammar,
+ and they have distinct associativities, then they are treated as
+ being non-associative.
+
+ The three paragraphs above also apply to identical notations (coming
+ from syntax declarations) for a given overloaded name.
+
+ Examples:
+
+ ```agda
+ module A where
+
+ infixr 5 _∷_
+ infixr 5 _∙_
+ infixl 3 _+_
+ infix 1 bind
+
+ syntax bind c (λ x → d) = x ← c , d
+
+ module B where
+
+ infix 5 _∷_
+ infixr 4 _∙_
+ -- No fixity declaration for _+_.
+ infixl 2 bind
+
+ syntax bind c d = c ∙ d
+
+ module C where
+
+ infixr 2 bind
+
+ syntax bind c d = c ∙ d
+
+ open A
+ open B
+ open C
+
+ -- _∷_ is infix 5.
+ -- _∙_ has two fixities: infixr 4 and infixr 5.
+ -- _+_ is infixl 3.
+ -- A.bind's notation is infix 1.
+ -- B.bind and C.bind's notations are infix 2.
+
+ -- There is one instance of "_ ∷ _" in the grammar, and one
+ -- instance of "_ + _".
+
+ -- There are three instances of "_ ∙ _" in the grammar, one
+ -- corresponding to A._∙_, one corresponding to B._∙_, and one
+ -- corresponding to both B.bind and C.bind.
+ ```
+
+### Reflection
+
+* The reflection framework has received a massive overhaul.
+
+ A new type of reflected type checking computations supplants most of
+ the old reflection primitives. The `quoteGoal`, `quoteContext` and
+ tactic primitives are deprecated and will be removed in the future,
+ and the `unquoteDecl` and `unquote` primitives have changed
+ behaviour. Furthermore the following primitive functions have been
+ replaced by builtin type checking computations:
+
+ ```agda
+ - primQNameType --> AGDATCMGETTYPE
+ - primQNameDefinition --> AGDATCMGETDEFINITION
+ - primDataConstructors --> subsumed by AGDATCMGETDEFINITION
+ - primDataNumberOfParameters --> subsumed by AGDATCMGETDEFINITION
+ ```
+
+ See below for details.
+
+* Types are no longer packaged with a sort.
+
+ The `AGDATYPE` and `AGDATYPEEL` built-ins have been
+ removed. Reflected types are now simply terms.
+
+* Reflected definitions have more information.
+
+ The type for reflected definitions has changed to
+
+ ```agda
+ data Definition : Set where
+ fun-def : List Clause → Definition
+ data-type : Nat → List Name → Definition -- parameters and constructors
+ record-type : Name → Definition -- name of the data/record type
+ data-con : Name → Definition -- name of the constructor
+ axiom : Definition
+ prim-fun : Definition
+ ```
+
+ Correspondingly the built-ins for function, data and record
+ definitions (`AGDAFUNDEF`, `AGDAFUNDEFCON`, `AGDADATADEF`,
+ `AGDARECORDDEF`) have been removed.
+
+* Reflected type checking computations.
+
+ There is a primitive `TC` monad representing type checking
+ computations. The `unquote`, `unquoteDecl`, and the new `unquoteDef`
+ all expect computations in this monad (see below). The interface to
+ the monad is the following
+
+ ```agda
+ -- Error messages can contain embedded names and terms.
+ data ErrorPart : Set where
+ strErr : String → ErrorPart
+ termErr : Term → ErrorPart
+ nameErr : Name → ErrorPart
+
+ {-# BUILTIN AGDAERRORPART ErrorPart #-}
+ {-# BUILTIN AGDAERRORPARTSTRING strErr #-}
+ {-# BUILTIN AGDAERRORPARTTERM termErr #-}
+ {-# BUILTIN AGDAERRORPARTNAME nameErr #-}
+
+ postulate
+ TC : ∀ {a} → Set a → Set a
+ returnTC : ∀ {a} {A : Set a} → A → TC A
+ bindTC : ∀ {a b} {A : Set a} {B : Set b} → TC A → (A → TC B) → TC B
+
+ -- Unify two terms, potentially solving metavariables in the process.
+ unify : Term → Term → TC ⊤
+
+ -- Throw a type error. Can be caught by catchTC.
+ typeError : ∀ {a} {A : Set a} → List ErrorPart → TC A
+
+ -- Block a type checking computation on a metavariable. This will abort
+ -- the computation and restart it (from the beginning) when the
+ -- metavariable is solved.
+ blockOnMeta : ∀ {a} {A : Set a} → Meta → TC A
+
+ -- Backtrack and try the second argument if the first argument throws a
+ -- type error.
+ catchTC : ∀ {a} {A : Set a} → TC A → TC A → TC A
+
+ -- Infer the type of a given term
+ inferType : Term → TC Type
+
+ -- Check a term against a given type. This may resolve implicit arguments
+ -- in the term, so a new refined term is returned. Can be used to create
+ -- new metavariables: newMeta t = checkType unknown t
+ checkType : Term → Type → TC Term
+
+ -- Compute the normal form of a term.
+ normalise : Term → TC Term
+
+ -- Get the current context.
+ getContext : TC (List (Arg Type))
+
+ -- Extend the current context with a variable of the given type.
+ extendContext : ∀ {a} {A : Set a} → Arg Type → TC A → TC A
+
+ -- Set the current context.
+ inContext : ∀ {a} {A : Set a} → List (Arg Type) → TC A → TC A
+
+ -- Quote a value, returning the corresponding Term.
+ quoteTC : ∀ {a} {A : Set a} → A → TC Term
+
+ -- Unquote a Term, returning the corresponding value.
+ unquoteTC : ∀ {a} {A : Set a} → Term → TC A
+
+ -- Create a fresh name.
+ freshName : String → TC QName
+
+ -- Declare a new function of the given type. The function must be defined
+ -- later using 'defineFun'. Takes an Arg Name to allow declaring instances
+ -- and irrelevant functions. The Visibility of the Arg must not be hidden.
+ declareDef : Arg QName → Type → TC ⊤
+
+ -- Define a declared function. The function may have been declared using
+ -- 'declareDef' or with an explicit type signature in the program.
+ defineFun : QName → List Clause → TC ⊤
+
+ -- Get the type of a defined name. Replaces 'primQNameType'.
+ getType : QName → TC Type
+
+ -- Get the definition of a defined name. Replaces 'primQNameDefinition'.
+ getDefinition : QName → TC Definition
+
+ {-# BUILTIN AGDATCM TC #-}
+ {-# BUILTIN AGDATCMRETURN returnTC #-}
+ {-# BUILTIN AGDATCMBIND bindTC #-}
+ {-# BUILTIN AGDATCMUNIFY unify #-}
+ {-# BUILTIN AGDATCMNEWMETA newMeta #-}
+ {-# BUILTIN AGDATCMTYPEERROR typeError #-}
+ {-# BUILTIN AGDATCMBLOCKONMETA blockOnMeta #-}
+ {-# BUILTIN AGDATCMCATCHERROR catchTC #-}
+ {-# BUILTIN AGDATCMINFERTYPE inferType #-}
+ {-# BUILTIN AGDATCMCHECKTYPE checkType #-}
+ {-# BUILTIN AGDATCMNORMALISE normalise #-}
+ {-# BUILTIN AGDATCMGETCONTEXT getContext #-}
+ {-# BUILTIN AGDATCMEXTENDCONTEXT extendContext #-}
+ {-# BUILTIN AGDATCMINCONTEXT inContext #-}
+ {-# BUILTIN AGDATCMQUOTETERM quoteTC #-}
+ {-# BUILTIN AGDATCMUNQUOTETERM unquoteTC #-}
+ {-# BUILTIN AGDATCMFRESHNAME freshName #-}
+ {-# BUILTIN AGDATCMDECLAREDEF declareDef #-}
+ {-# BUILTIN AGDATCMDEFINEFUN defineFun #-}
+ {-# BUILTIN AGDATCMGETTYPE getType #-}
+ {-# BUILTIN AGDATCMGETDEFINITION getDefinition #-}
+ ```
+
+* Builtin type for metavariables
+
+ There is a new builtin type for metavariables used by the new reflection
+ framework. It is declared as follows and comes with primitive equality,
+ ordering and show.
+
+ ```agda
+ postulate Meta : Set
+ {-# BUILTIN AGDAMETA Meta #-}
+ primitive primMetaEquality : Meta → Meta → Bool
+ primitive primMetaLess : Meta → Meta → Bool
+ primitive primShowMeta : Meta → String
+ ```
+
+ There are corresponding new constructors in the `Term` and `Literal`
+ data types:
+
+ ```agda
+ data Term : Set where
+ ...
+ meta : Meta → List (Arg Term) → Term
+
+ {-# BUILTIN AGDATERMMETA meta #-}
+
+ data Literal : Set where
+ ...
+ meta : Meta → Literal
+
+ {-# BUILTIN AGDALITMETA meta #-}
+ ```
+
+* Builtin unit type
+
+ The type checker needs to know about the unit type, which you can
+ allow by
+
+ ```agda
+ record ⊤ : Set where
+ {-# BUILTIN UNIT ⊤ #-}
+ ```
+
+* Changed behaviour of `unquote`
+
+ The `unquote` primitive now expects a type checking computation
+ instead of a pure term. In particular `unquote e` requires
+
+ ```agda
+ e : Term → TC ⊤
+ ```
+
+ where the argument is the representation of the hole in which the
+ result should go. The old `unquote` behaviour (where `unquote`
+ expected a `Term` argument) can be recovered by
+
+ ```agda
+ OLD: unquote v
+ NEW: unquote λ hole → unify hole v
+ ```
+
+* Changed behaviour of `unquoteDecl`
+
+ The `unquoteDecl` primitive now expects a type checking computation
+ instead of a pure function definition. It is possible to define
+ multiple (mutually recursive) functions at the same time. More
+ specifically
+
+ ```agda
+ unquoteDecl x₁ .. xₙ = m
+ ```
+
+ requires `m : TC ⊤` and that `x₁ .. xₙ` are defined (using
+ `declareDef` and `defineFun`) after executing `m`. As before `x₁
+ .. xₙ : QName` in `m`, but have their declared types outside the
+ `unquoteDecl`.
+
+* New primitive `unquoteDef`
+
+ There is a new declaration
+
+ ```agda
+ unquoteDef x₁ .. xₙ = m
+ ```
+
+ This works exactly as `unquoteDecl` (see above) with the exception
+ that `x₁ .. xₙ` are required to already be declared.
+
+ The main advantage of `unquoteDef` over `unquoteDecl` is that
+ `unquoteDef` is allowed in mutual blocks, allowing mutually
+ recursion between generated definitions and hand-written
+ definitions.
+
+* The reflection interface now exposes the name hint (as a string)
+ for variables. As before, the actual binding structure is with
+ de Bruijn indices. The String value is just a hint used as a prefix
+ to help display the variable. The type `Abs` is a new builtin type used
+ for the constructors `Term.lam`, `Term.pi`, `Pattern.var`
+ (bultins `AGDATERMLAM`, `AGDATERMPI` and `AGDAPATVAR`).
+
+ ```agda
+ data Abs (A : Set) : Set where
+ abs : (s : String) (x : A) → Abs A
+ {-# BUILTIN ABS Abs #-}
+ {-# BUILTIN ABSABS abs #-}
+ ```
+
+ Updated constructor types:
+
+ ```agda
+ Term.lam : Hiding → Abs Term → Term
+ Term.pi : Arg Type → Abs Type → Term
+ Pattern.var : String → Pattern
+ ```
+
+* Reflection-based macros
+
+ Macros are functions of type `t1 → t2 → .. → Term → TC ⊤` that are
+ defined in a `macro` block. Macro application is guided by the type
+ of the macro, where `Term` arguments desugar into the `quoteTerm`
+ syntax and `Name` arguments into the `quote` syntax. Arguments of
+ any other type are preserved as-is. The last `Term` argument is the
+ hole term given to `unquote` computation (see above).
+
+ For example, the macro application `f u v w` where the macro `f` has
+ the type `Term → Name → Bool → Term → TC ⊤` desugars into `unquote
+ (f (quoteTerm u) (quote v) w)`
+
+ Limitations:
+
+ - Macros cannot be recursive. This can be worked around by defining the
+ recursive function outside the macro block and have the macro call the
+ recursive function.
+
+ Silly example:
+
+ ```agda
+ macro
+ plus-to-times : Term → Term → TC ⊤
+ plus-to-times (def (quote _+_) (a ∷ b ∷ [])) hole = unify hole (def (quote _*_) (a ∷ b ∷ []))
+ plus-to-times v hole = unify hole v
+
+ thm : (a b : Nat) → plus-to-times (a + b) ≡ a * b
+ thm a b = refl
+ ```
+
+ Macros are most useful when writing tactics, since they let you hide the
+ reflection machinery. For instance, suppose you have a solver
+
+ ```agda
+ magic : Type → Term
+ ```
+
+ that takes a reflected goal and outputs a proof (when successful). You can
+ then define the following macro
+
+ ```agda
+ macro
+ by-magic : Term → TC ⊤
+ by-magic hole =
+ bindTC (inferType hole) λ goal →
+ unify hole (magic goal)
+ ```
+
+ This lets you apply the magic tactic without any syntactic noise at all:
+
+ ```agda
+ thm : ¬ P ≡ NP
+ thm = by-magic
+ ```
+
+### Literals and built-ins
+
+* Overloaded number literals.
+
+ You can now overload natural number literals using the new builtin
+ `FROMNAT`:
+
+ ```agda
+ {-# BUILTIN FROMNAT fromNat #-}
+ ```
+
+ The target of the builtin should be a defined name. Typically you would do
+ something like
+
+ ```agda
+ record Number (A : Set) : Set where
+ field fromNat : Nat → A
+
+ open Number {{...}} public
+
+ {-# BUILTIN FROMNAT fromNat #-}
+ ```
+
+ This will cause number literals `n` to be desugared to `fromNat n`
+ before type checking.
+
+* Negative number literals.
+
+ Number literals can now be negative. For floating point literals it
+ works as expected. For integer literals there is a new builtin
+ `FROMNEG` that enables negative integer literals:
+
+ ```agda
+ {-# BUILTIN FROMNEG fromNeg #-}
+ ```
+
+ This causes negative literals `-n` to be desugared to `fromNeg n`.
+
+* Overloaded string literals.
+
+ String literals can be overladed using the `FROMSTRING` builtin:
+
+ ```agda
+ {-# BUILTIN FROMSTRING fromString #-}
+ ```
+
+ The will cause string literals `s` to be desugared to `fromString s`
+ before type checking.
+
+* Change to builtin integers.
+
+ The `INTEGER` builtin now needs to be bound to a datatype with two
+ constructors that should be bound to the new builtins `INTEGERPOS`
+ and `INTEGERNEGSUC` as follows:
+
+ ```agda
+ data Int : Set where
+ pos : Nat -> Int
+ negsuc : Nat -> Int
+ {-# BUILTIN INTEGER Int #-}
+ {-# BUILTIN INTEGERPOS pos #-}
+ {-# BUILTIN INTEGERNEGSUC negsuc #-}
+ ```
+
+ where `negsuc n` represents the integer `-n - 1`. For instance, `-5`
+ is represented as `negsuc 4`. All primitive functions on integers
+ except `primShowInteger` have been removed, since these can be
+ defined without too much trouble on the above representation using
+ the corresponding functions on natural numbers.
+
+ The primitives that have been removed are
+
+ ```agda
+ primIntegerPlus
+ primIntegerMinus
+ primIntegerTimes
+ primIntegerDiv
+ primIntegerMod
+ primIntegerEquality
+ primIntegerLess
+ primIntegerAbs
+ primNatToInteger
+ ```
+
+* New primitives for strict evaluation
+
+ ```agda
+ primitive
+ primForce : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) → (∀ x → B x) → B x
+ primForceLemma : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) (f : ∀ x → B x) → primForce x f ≡ f x
+ ```
+
+ `primForce x f` evaluates to `f x` if x is in weak head normal form,
+ and `primForceLemma x f` evaluates to `refl` in the same
+ situation. The following values are considered to be in weak head
+ normal form:
+
+ - constructor applications
+ - literals
+ - lambda abstractions
+ - type constructor (data/record types) applications
+ - function types
+ - Set a
+
+### Modules
+
+* Modules in import directives
+
+ When you use `using`/`hiding`/`renaming` on a name it now
+ automatically applies to any module of the same name, unless you
+ explicitly mention the module. For instance,
+
+ ```agda
+ open M using (D)
+ ```
+
+ is equivalent to
+
+ ```agda
+ open M using (D; module D)
+ ```
+
+ if `M` defines a module `D`. This is most useful for record and data
+ types where you always get a module of the same name as the type.
+
+ With this feature there is no longer useful to be able to qualify a
+ constructor (or field) by the name of the data type even when it
+ differs from the name of the corresponding module. The follow
+ (weird) code used to work, but doesn't work anymore:
+
+ ```agda
+ module M where
+ data D where
+ c : D
+ open M using (D) renaming (module D to MD)
+ foo : D
+ foo = D.c
+ ```
+
+ If you want to import only the type name and not the module you have to hide
+ it explicitly:
+
+ ```agda
+ open M using (D) hiding (module D)
+ ```
+
+ See discussion on
+ Issue [#836](https://github.com/agda/agda/issues/836).
+
+* Private definitions of a module are no longer in scope at the Emacs
+ mode top-level.
+
+ The reason for this change is that `.agdai-files` are stripped of
+ unused private definitions (which can yield significant performance
+ improvements for module-heavy code).
+
+ To test private definitions you can create a hole at the bottom of
+ the module, in which private definitions will be visible.
+
+### Records
+
+* New record directives `eta-equality`/`no-eta-equality`
+
+ The keywords `eta-equality`/`no-eta-equality` enable/disable eta
+ rules for the (inductive) record type being declared.
+
+ ```agda
+ record Σ (A : Set) (B : A -> Set) : Set where
+ no-eta-equality
+ constructor _,_
+ field
+ fst : A
+ snd : B fst
+ open Σ
+
+ -- fail : ∀ {A : Set}{B : A -> Set} → (x : Σ A B) → x ≡ (fst x , snd x)
+ -- fail x = refl
+ --
+ -- x != fst x , snd x of type Σ .A .B
+ -- when checking that the expression refl has type x ≡ (fst x , snd x)
+ ```
+
+* Building records from modules.
+
+ The `record { <fields> }` syntax is now extended to accept module
+ names as well. Fields are thus defined using the corresponding
+ definitions from the given module.
+
+ For instance assuming this record type `R` and module `M`:
+
+ ```agda
+ record R : Set where
+ field
+ x : X
+ y : Y
+ z : Z
+
+ module M where
+ x = {! ... !}
+ y = {! ... !}
+
+ r : R
+ r = record { M; z = {! ... !} }
+ ```
+
+ Previously one had to write `record { x = M.x; y = M.y; z = {! ... !} }`.
+
+ More precisely this construction now supports any combination of explicit
+ field definitions and applied modules.
+
+ If a field is both given explicitly and available in one of the modules,
+ then the explicit one takes precedence.
+
+ If a field is available in more than one module then this is ambiguous
+ and therefore rejected. As a consequence the order of assignments does
+ not matter.
+
+ The modules can be both applied to arguments and have import directives
+ such as `hiding`, `using`, and `renaming`. In particular this construct
+ subsumes the record update construction.
+
+ Here is an example of record update:
+
+ ```agda
+ -- Record update. Same as: record r { y = {! ... !} }
+ r2 : R
+ r2 = record { R r; y = {! ... !} }
+ ```
+
+ A contrived example showing the use of `hiding`/`renaming`:
+
+ ```agda
+ module M2 (a : A) where
+ w = {! ... !}
+ z = {! ... !}
+
+ r3 : A → R
+ r3 a = record { M hiding (y); M2 a renaming (w to y) }
+ ```
+
+* Record patterns are now accepted.
+
+ Examples:
+
+ ```agda
+ swap : {A B : Set} (p : A × B) → B × A
+ swap record{ proj₁ = a; proj₂ = b } = record{ proj₁ = b; proj₂ = a }
+
+ thd3 : ...
+ thd3 record{ proj₂ = record { proj₂ = c }} = c
+ ```
+
+* Record modules now properly hide all their parameters
+ [Issue [#1759](https://github.com/agda/agda/issues/1759)]
+
+ Previously parameters to parent modules were not hidden in the record
+ module, resulting in different behaviour between
+
+ ```agda
+ module M (A : Set) where
+ record R (B : Set) : Set where
+ ```
+
+ and
+
+ ```agda
+ module M where
+ record R (A B : Set) : Set where
+ ```
+
+ where in the former case, `A` would be an explicit argument to the module
+ `M.R`, but implicit in the latter case. Now `A` is implicit in both cases.
+
+### Instance search
+
+* Performance has been improved, recursive instance search which was
+ previously exponential in the depth is now only quadratic.
+
+* Constructors of records and datatypes are not anymore automatically
+ considered as instances, you have to do so explicitely, for
+ instance:
+
+ ```agda
+ -- only [b] is an instance of D
+ data D : Set where
+ a : D
+ instance
+ b : D
+ c : D
+
+ -- the constructor is now an instance
+ record tt : Set where
+ instance constructor tt
+ ```
+
+* Lambda-bound variables are no longer automatically considered
+ instances.
+
+ Lambda-bound variables need to be bound as instance arguments to be
+ considered for instance search. For example,
+
+ ```agda
+ _==_ : {A : Set} {{_ : Eq A}} → A → A → Bool
+
+ fails : {A : Set} → Eq A → A → Bool
+ fails eqA x = x == x
+
+ works : {A : Set} {{_ : Eq A}} → A → Bool
+ works x = x == x
+ ```
+
+* Let-bound variables are no longer automatically considered
+ instances.
+
+ To make a let-bound variable available as an instance it needs to be
+ declared with the `instance` keyword, just like top-level
+ instances. For example,
+
+ ```agda
+ mkEq : {A : Set} → (A → A → Bool) → Eq A
+
+ fails : {A : Set} → (A → A → Bool) → A → Bool
+ fails eq x = let eqA = mkEq eq in x == x
+
+ works : {A : Set} → (A → A → Bool) → A → Bool
+ works eq x = let instance eqA = mkEq eq in x == x
+ ```
+
+* Record fields can be declared instances.
+
+ For example,
+
+ ```agda
+ record EqSet : Set₁ where
+ field
+ set : Set
+ instance eq : Eq set
+ ```
+
+ This causes the projection function `eq : (E : EqSet) → Eq (set E)`
+ to be considered for instance search.
+
+* Instance search can now find arguments in variable types (but such
+ candidates can only be lambda-bound variables, they can’t be
+ declared as instances)
+
+ ```agda
+ module _ {A : Set} (P : A → Set) where
+
+ postulate
+ bla : {x : A} {{_ : P x}} → Set → Set
+
+ -- Works, the instance argument is found in the context
+ test : {x : A} {{_ : P x}} → Set → Set
+ test B = bla B
+
+ -- Still forbidden, because [P] could be instantiated later to anything
+ instance
+ postulate
+ forbidden : {x : A} → P x
+ ```
+
+* Instance search now refuses to solve constraints with unconstrained
+ metavariables, since this can lead to non-termination.
+
+ See [Issue [#1532](https://github.com/agda/agda/issues/1523)] for an
+ example.
+
+* Top-level instances are now only considered if they are in
+ scope. [Issue [#1913](https://github.com/agda/agda/issues/1913)]
+
+ Note that lambda-bound instances need not be in scope.
+
+### Other changes
+
+* Unicode ellipsis character is allowed for the ellipsis token `...`
+ in `with` expressions.
+
+* `Prop` is no longer a reserved word.
+
+Type checking
+-------------
+
+* Large indices.
+
+ Force constructor arguments no longer count towards the size of a datatype.
+ For instance, the definition of equality below is accepted.
+
+ ```agda
+ data _≡_ {a} {A : Set a} : A → A → Set where
+ refl : ∀ x → x ≡ x
+ ```
+
+ This gets rid of the asymmetry that the version of equality which indexes
+ only on the second argument could be small, but not the version above which
+ indexes on both arguments.
+
+* Detection of datatypes that satisfy K (i.e. sets)
+
+ Agda will now try to detect datatypes that satisfy K when
+ `--without-K` is enabled. A datatype satisfies K when it follows
+ these three rules:
+
+ - The types of all non-recursive constructor arguments should satisfy K.
+
+ - All recursive constructor arguments should be first-order.
+
+ - The types of all indices should satisfy K.
+
+ For example, the types `Nat`, `List Nat`, and `x ≡ x` (where `x :
+ Nat`) are all recognized by Agda as satisfying K.
+
+* New unifier for case splitting
+
+ The unifier used by Agda for case splitting has been completely
+ rewritten. The new unifier takes a much more type-directed approach
+ in order to avoid the problems in issues
+ [#1406](https://github.com/agda/agda/issues/1406),
+ [#1408](https://github.com/agda/agda/issues/1408),
+ [#1427](https://github.com/agda/agda/issues/1427), and
+ [#1435](https://github.com/agda/agda/issues/1435).
+
+ The new unifier also has eta-equality for record types
+ built-in. This should avoid unnecessary case splitting on record
+ constructors and improve the performance of Agda on code that
+ contains deeply nested record patterns (see issues
+ [#473](https://github.com/agda/agda/issues/473),
+ [#635](https://github.com/agda/agda/issues/635),
+ [#1575](https://github.com/agda/agda/issues/1575),
+ [#1603](https://github.com/agda/agda/issues/1603),
+ [#1613](https://github.com/agda/agda/issues/1613), and
+ [#1645](https://github.com/agda/agda/issues/1645)).
+
+ In some cases, the locations of the dot patterns computed by the
+ unifier did not correspond to the locations given by the user (see
+ Issue [#1608](https://github.com/agda/agda/issues/1608)). This has
+ now been fixed by adding an extra step after case splitting that
+ checks whether the user-written patterns are compatible with the
+ computed ones.
+
+ In some rare cases, the new unifier is still too restrictive when
+ `--without-K` is enabled because it cannot generalize over the
+ datatype indices (yet). For example, the following code is rejected:
+
+ ```agda
+ data Bar : Set₁ where
+ bar : Bar
+ baz : (A : Set) → Bar
+
+ data Foo : Bar → Set where
+ foo : Foo bar
+
+ test : foo ≡ foo → Set₁
+ test refl = Set
+ ```
+
+* The aggressive behaviour of `with` introduced in 2.4.2.5 has been
+ rolled back
+ [Issue [#1692](https://github.com/agda/agda/issues/1692)]. With no
+ longer abstracts in the types of variables appearing in the
+ with-expressions. [Issue [#745](https://github.com/agda/agda/issues/745)]
+
+ This means that the following example no longer works:
+
+ ```agda
+ fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a
+ fails f b with a | f b
+ fails f b | .b | refl = f b
+ ```
+
+ The `with` no longer abstracts the type of `f` over `a`, since `f`
+ appears in the second with-expression `f b`. You can use a nested
+ `with` to make this example work.
+
+ This example does work again:
+
+ ```agda
+ test : ∀{A : Set}{a : A}{f : A → A} (p : f a ≡ a) → f (f a) ≡ a
+ test p rewrite p = p
+ ```
+
+ After `rewrite p` the goal has changed to `f a ≡ a`, but the type
+ of `p` has not been rewritten, thus, the final `p` solves the goal.
+
+ The following, which worked in 2.4.2.5, no longer works:
+
+ ```agda
+ fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a
+ fails f b rewrite f b = f b
+ ```
+
+ The rewrite with `f b : a ≡ b` is not applied to `f` as
+ the latter is part of the rewrite expression `f b`. Thus,
+ the type of `f` remains untouched, and the changed goal
+ `b ≡ b` is not solved by `f b`.
+
+* When using `rewrite` on a term `eq` of type `lhs ≡ rhs`, the `lhs`
+ is no longer abstracted in `rhs`
+ [Issue [#520](https://github.com/agda/agda/issues/520)]. This means
+ that
+
+ ```agda
+ f pats rewrite eq = body
+ ```
+
+ is more than syntactic sugar for
+
+ ```agda
+ f pats with lhs | eq
+ f pats | _ | refl = body
+ ```
+
+ In particular, the following application of `rewrite` is now
+ possible
+
+ ```agda
+ id : Bool → Bool
+ id true = true
+ id false = false
+
+ is-id : ∀ x → x ≡ id x
+ is-id true = refl
+ is-id false = refl
+
+ postulate
+ P : Bool → Set
+ b : Bool
+ p : P (id b)
+
+ proof : P b
+ proof rewrite is-id b = p
+ ```
+
+ Previously, this was desugared to
+
+ ```agda
+ proof with b | is-id b
+ proof | _ | refl = p
+ ```
+
+ which did not type check as `refl` does not have type `b ≡ id b`.
+ Now, Agda gets the task of checking `refl : _ ≡ id b` leading to
+ instantiation of `_` to `id b`.
+
+Compiler backends
+-----------------
+
+* Major Bug Fixes:
+
+ - Function clauses with different arities are now always compiled
+ correctly by the GHC/UHC
+ backends. (Issue [#727](https://github.com/agda/agda/issues/727))
+
+* Co-patterns
+
+ - The GHC/UHC backends now support co-patterns. (Issues
+ [#1567](https://github.com/agda/agda/issues/1567),
+ [#1632](https://github.com/agda/agda/issues/1632))
+
+* Optimizations
+
+ - Builtin naturals are now represented as arbitrary-precision
+ Integers. See the user manual, section
+ "Agda Compilers -> Optimizations" for details.
+
+* GHC Haskell backend (MAlonzo)
+
+ - Pragmas
+
+ Since builtin naturals are compiled to `Integer` you can no longer
+ give a `{-# COMPILED_DATA #-}` pragma for `Nat`. The same goes for
+ builtin booleans, integers, floats, characters and strings which
+ are now hard-wired to appropriate Haskell types.
+
+* UHC compiler backend
+
+ A new backend targeting the Utrecht Haskell Compiler (UHC) is
+ available. It targets the UHC Core language, and it's design is
+ inspired by the Epic backend. See the user manual, section "Agda
+ Compilers -> UHC Backend" for installation instructions.
+
+ - FFI
+
+ The UHC backend has a FFI to Haskell similar to MAlonzo's. The
+ target Haskell code also needs to be compilable using UHC, which
+ does not support the Haskell base library version 4.*.
+
+ FFI pragmas for the UHC backend are not checked in any way. If the
+ pragmas are wrong, bad things will happen.
+
+ - Imports
+
+ Additional Haskell modules can be brought into scope with the
+ `IMPORT_UHC` pragma:
+
+ ```agda
+ {-# IMPORT_UHC Data.Char #-}
+ ```
+
+ The Haskell modules `UHC.Base` and `UHC.Agda.Builtins` are always in
+ scope and don't need to be imported explicitly.
+
+ - Datatypes
+
+ Agda datatypes can be bound to Haskell datatypes as follows:
+
+ Haskell:
+ ```haskell
+ data HsData a = HsCon1 | HsCon2 (HsData a)
+ ```
+
+ Agda:
+ ```agda
+ data AgdaData (A : Set) : Set where
+ AgdaCon1 : AgdaData A
+ AgdaCon2 : AgdaData A -> AgdaData A
+ {-# COMPILED_DATA_UHC AgdaData HsData HsCon1 HsCon2 #-}
+ ```
+
+ The mapping has to cover all constructors of the used Haskell
+ datatype, else runtime behavior is undefined!
+
+ There are special reserved names to bind Agda datatypes to certain
+ Haskell datatypes. For example, this binds an Agda datatype to
+ Haskell's list datatype:
+
+ Agda:
+ ```agda
+ data AgdaList (A : Set) : Set where
+ Nil : AgdaList A
+ Cons : A -> AgdaList A -> AgdaList A
+ {-# COMPILED_DATA_UHC AgdaList __LIST__ __NIL__ __CONS__ #-}
+ ```
+
+ The following "magic" datatypes are available:
+
+ ```
+ HS Datatype | Datatype Pragma | HS Constructor | Constructor Pragma
+ () __UNIT__ () __UNIT__
+ List __LIST__ (:) __CONS__
+ [] __NIL__
+ Bool __BOOL__ True __TRUE__
+ False __FALSE__
+ ```
+
+ - Functions
+
+ Agda postulates can be bound to Haskell functions. Similar as in
+ MAlonzo, all arguments of type `Set` need to be dropped before
+ calling Haskell functions. An example calling the return function:
+
+ Agda:
+ ```agda
+ postulate hs-return : {A : Set} -> A -> IO A
+ {-# COMPILED_UHC hs-return (\_ -> UHC.Agda.Builtins.primReturn) #-}
+ ```
+
+Emacs mode and interaction
+--------------------------
+
+* Module contents (`C-c C-o`) now also works for
+ records. [See Issue [#1926](https://github.com/agda/agda/issues/1926) ]
+ If you have an inferable expression of record type in an interaction
+ point, you can invoke `C-c C-o` to see its fields and types.
+ Example
+
+ ```agda
+ record R : Set where
+ field f : A
+
+ test : R → R
+ test r = {!r!} -- C-c C-o here
+ ```
+
+* Less aggressive error notification.
+
+ Previously Emacs could jump to the position of an error even if the
+ type-checking process was not initiated in the current buffer. Now
+ this no longer happens: If the type-checking process was initiated
+ in another buffer, then the cursor is moved to the position of the
+ error in the buffer visiting the file (if any) and in every window
+ displaying the file, but focus should not change from one file to
+ another.
+
+ In the cases where focus does change from one file to another, one
+ can now use the go-back functionality to return to the previous
+ position.
+
+* Removed the `agda-include-dirs` customization parameter.
+
+ Use `agda-program-args` with `-iDIR` or `-lLIB` instead, or add
+ libraries to `~/.agda/defaults`
+ (`C:/Users/USERNAME/AppData/Roaming/agda/defaults` or similar on
+ Windows). See Library management, above, for more information.
+
+Tools
+-----
+
+### LaTeX-backend
+
+* The default font has been changed to XITS (which is part of TeX Live):
+
+ http://www.ctan.org/tex-archive/fonts/xits/
+
+ This font is more complete with respect to Unicode.
+
+### agda-ghc-names
+
+* New tool: The command
+
+ ```
+ agda-ghc-names fixprof <compile-dir> <ProgName>.prof
+ ```
+
+ converts `*.prof` files obtained from profiling runs of
+ MAlonzo-compiled code to `*.agdaIdents.prof`, with the original Agda
+ identifiers replacing the MAlonzo-generated Haskell identifiers.
+
+ For usage and more details, see `src/agda-ghc-names/README.txt`.
+
+Highlighting and textual backends
+---------------------------------
+
+* Names in import directives are now highlighted and are clickable.
+ [Issue [#1714](https://github.com/agda/agda/issues/1714)] This leads
+ also to nicer printing in the LaTeX and html backends.
+
+Fixed issues
+------------
+
+See
+[bug tracker (milestone 2.5.1)](https://github.com/agda/agda/issues?q=milestone%3A2.5.1+is%3Aclosed)
+
+Release notes for Agda version 2.4.2.5
+======================================
+
+Installation and infrastructure
+-------------------------------
+
+* Added support for GHC 7.10.3.
+
+* Added `cpphs` Cabal flag
+
+ Turn on/off this flag to choose cpphs/cpp as the C preprocessor.
+
+ This flag is turn on by default.
+
+ (This flag was added in Agda 2.4.2.1 but it was not documented)
+
+Pragmas and options
+-------------------
+
+* Termination pragmas are no longer allowed inside `where` clauses
+ [Issue [#1137](https://github.com/agda/agda/issues/1137)].
+
+Type checking
+-------------
+
+* `with`-abstraction is more aggressive, abstracts also in types of
+ variables that are used in the `with`-expressions, unless they are
+ also used in the types of the
+ `with`-expressions. [Issue [#1692](https://github.com/agda/agda/issues/1692)]
+
+ Example:
+
+ ```agda
+ test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a
+ test f b with a | f b
+ test f b | .b | refl = f b
+ ```
+
+ Previously, `with` would not abstract in types of variables that
+ appear in the `with`-expressions, in this case, both `f` and `b`,
+ leaving their types unchanged. Now, it tries to abstract in `f`, as
+ only `b` appears in the types of the `with`-expressions which are
+ `A` (of `a`) and `a ≡ b` (of `f b`). As a result, the type of `f`
+ changes to `(x : A) → b ≡ x` and the type of the goal to `b ≡ b` (as
+ previously).
+
+ This also affects `rewrite`, which is implemented in terms of
+ `with`.
+
+ ```agda
+ test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a
+ test f b rewrite f b = f b
+ ```
+
+ As the new `with` is not fully backwards-compatible, some parts of
+ your Agda developments using `with` or `rewrite` might need
+ maintenance.
+
+Fixed issues
+------------
+
+See [bug tracker](https://github.com/agda/agda/issues)
+
+[#1407](https://github.com/agda/agda/issues/1497)
+
+[#1518](https://github.com/agda/agda/issues/1518)
+
+[#1670](https://github.com/agda/agda/issues/1670)
+
+[#1677](https://github.com/agda/agda/issues/1677)
+
+[#1698](https://github.com/agda/agda/issues/1698)
+
+[#1701](https://github.com/agda/agda/issues/1701)
+
+[#1710](https://github.com/agda/agda/issues/1710)
+
+[#1718](https://github.com/agda/agda/issues/1718)
+
+Release notes for Agda version 2.4.2.4
+======================================
+
+Installation and infrastructure
+-------------------------------
+
+* Removed support for GHC 7.4.2.
+
+Pragmas and options
+-------------------
+
+* Option `--copatterns` is now on by default. To switch off
+ parsing of copatterns, use:
+
+ ```agda
+ {-# OPTIONS --no-copatterns #-}
+ ```
+
+* Option `--rewriting` is now needed to use `REWRITE` pragmas and
+ rewriting during reduction. Rewriting is not `--safe`.
+
+ To use rewriting, first specify a relation symbol `R` that will
+ later be used to add rewrite rules. A canonical candidate would be
+ propositional equality
+
+ ```agda
+ {-# BUILTIN REWRITE _≡_ #-}
+ ```
+
+ but any symbol `R` of type `Δ → A → A → Set i` for some `A` and `i`
+ is accepted. Then symbols `q` can be added to rewriting provided
+ their type is of the form `Γ → R ds l r`. This will add a rewrite
+ rule
+
+ ```
+ Γ ⊢ l ↦ r : A[ds/Δ]
+ ```
+
+ to the signature, which fires whenever a term is an instance of `l`.
+ For example, if
+
+ ```agda
+ plus0 : ∀ x → x + 0 ≡ x
+ ```
+
+ (ideally, there is a proof for `plus0`, but it could be a
+ postulate), then
+
+ ```agda
+ {-# REWRITE plus0 #-}
+ ```
+
+ will prompt Agda to rewrite any well-typed term of the form `t + 0`
+ to `t`.
+
+ Some caveats: Agda accepts and applies rewrite rules naively, it is
+ very easy to break consistency and termination of type checking.
+ Some examples of rewrite rules that should *not* be added:
+
+ ```agda
+ refl : ∀ x → x ≡ x -- Agda loops
+ plus-sym : ∀ x y → x + y ≡ y + x -- Agda loops
+ absurd : true ≡ false -- Breaks consistency
+ ```
+
+ Adding only proven equations should at least preserve consistency,
+ but this is only a conjecture, so know what you are doing! Using
+ rewriting, you are entering into the wilderness, where you are on
+ your own!
+
+Language
+--------
+
+* `forall` / `∀` now parses like `λ`, i.e., the following parses now
+ [Issue [#1583](https://github.com/agda/agda/issues/1538)]:
+
+ ```agda
+ ⊤ × ∀ (B : Set) → B → B
+ ```
+
+* The underscore pattern `_` can now also stand for an inaccessible
+ pattern (dot pattern). This alleviates the need for writing `._`.
+ [Issue #[1605](https://github.com/agda/agda/issues/1605)] Instead of
+
+ ```agda
+ transVOld : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c
+ transVOld _ ._ ._ refl refl = refl
+ ```
+
+ one can now write
+
+ ```agda
+ transVNew : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c
+ transVNew _ _ _ refl refl = refl
+ ```
+
+ and let Agda decide where to put the dots. This was always possible
+ by using hidden arguments
+
+ ```agda
+ transH : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c
+ transH refl refl = refl
+ ```
+
+ which is now equivalent to
+
+ ```agda
+ transHNew : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c
+ transHNew {a = _}{b = _}{c = _} refl refl = refl
+ ```
+
+ Before, underscore `_` stood for an unnamed variable that could not
+ be instantiated by an inaccessible pattern. If one no wants to
+ prevent Agda from instantiating, one needs to use a variable name
+ other than underscore (however, in practice this situation seems
+ unlikely).
+
+Type checking
+-------------
+
+* Polarity of phantom arguments to data and record types has
+ changed. [Issue [#1596](https://github.com/agda/agda/issues/1596)]
+ Polarity of size arguments is Nonvariant (both monotone and
+ antitone). Polarity of other arguments is Covariant (monotone).
+ Both were Invariant before (neither monotone nor antitone).
+
+ The following example type-checks now:
+
+ ```agda
+ open import Common.Size
+
+ -- List should be monotone in both arguments
+ -- (even when `cons' is missing).
+
+ data List (i : Size) (A : Set) : Set where
+ [] : List i A
+
+ castLL : ∀{i A} → List i (List i A) → List ∞ (List ∞ A)
+ castLL x = x
+
+ -- Stream should be antitone in the first and monotone in the second argument
+ -- (even with field `tail' missing).
+
+ record Stream (i : Size) (A : Set) : Set where
+ coinductive
+ field
+ head : A
+
+ castSS : ∀{i A} → Stream ∞ (Stream ∞ A) → Stream i (Stream i A)
+ castSS x = x
+ ```
+
+* `SIZELT` lambdas must be consistent
+ [Issue [#1523](https://github.com/agda/agda/issues/1523), see Abel
+ and Pientka, ICFP 2013]. When lambda-abstracting over type (`Size<
+ size`) then `size` must be non-zero, for any valid instantiation of
+ size variables.
+
+ - The good:
+
+ ```agda
+ data Nat (i : Size) : Set where
+ zero : ∀ (j : Size< i) → Nat i
+ suc : ∀ (j : Size< i) → Nat j → Nat i
+
+ {-# TERMINATING #-}
+ -- This definition is fine, the termination checker is too strict at the moment.
+ fix : ∀ {C : Size → Set}
+ → (∀ i → (∀ (j : Size< i) → Nat j -> C j) → Nat i → C i)
+ → ∀ i → Nat i → C i
+ fix t i (zero j) = t i (λ (k : Size< i) → fix t k) (zero j)
+ fix t i (suc j n) = t i (λ (k : Size< i) → fix t k) (suc j n)
+ ```
+
+ The `λ (k : Size< i)` is fine in both cases, as context
+
+ ```agda
+ i : Size, j : Size< i
+ ```
+
+ guarantees that `i` is non-zero.
+
+ - The bad:
+
+ ```agda
+ record Stream {i : Size} (A : Set) : Set where
+ coinductive
+ constructor _∷ˢ_
+ field
+ head : A
+ tail : ∀ {j : Size< i} → Stream {j} A
+ open Stream public
+
+ _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A
+ [] ++ˢ s = s
+ (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s)
+ ```
+
+ This fails, maybe unjustified, at
+
+ ```agda
+ i : Size, s : Stream {i} A
+ ⊢
+ a ∷ˢ (λ {j : Size< i} → as ++ˢ s)
+ ```
+
+ Fixed by defining the constructor by copattern matching:
+
+ ```agda
+ record Stream {i : Size} (A : Set) : Set where
+ coinductive
+ field
+ head : A
+ tail : ∀ {j : Size< i} → Stream {j} A
+ open Stream public
+
+ _∷ˢ_ : ∀ {i A} → A → Stream {i} A → Stream {↑ i} A
+ head (a ∷ˢ as) = a
+ tail (a ∷ˢ as) = as
+
+ _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A
+ [] ++ˢ s = s
+ (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s)
+ ```
+
+ - The ugly:
+
+ ```agda
+ fix : ∀ {C : Size → Set}
+ → (∀ i → (∀ (j : Size< i) → C j) → C i)
+ → ∀ i → C i
+ fix t i = t i λ (j : Size< i) → fix t j
+ ```
+
+ For `i=0`, there is no such `j` at runtime, leading to looping
+ behavior.
+
+Interaction
+-----------
+
+* Issue [#635](https://github.com/agda/agda/issues/635) has been
+ fixed. Case splitting does not spit out implicit record patterns
+ any more.
+
+ ```agda
+ record Cont : Set₁ where
+ constructor _◃_
+ field
+ Sh : Set
+ Pos : Sh → Set
+
+ open Cont
+
+ data W (C : Cont) : Set where
+ sup : (s : Sh C) (k : Pos C s → W C) → W C
+
+ bogus : {C : Cont} → W C → Set
+ bogus w = {!w!}
+ ```
+
+ Case splitting on `w` yielded, since the fix of
+ Issue [#473](https://github.com/agda/agda/issues/473),
+
+ ```agda
+ bogus {Sh ◃ Pos} (sup s k) = ?
+ ```
+
+ Now it gives, as expected,
+
+ ```agda
+ bogus (sup s k) = ?
+ ```
+
+Performance
+-----------
+
+* As one result of the 21st Agda Implementor's Meeting (AIM XXI),
+ serialization of the standard library is 50% faster (time reduced by
+ a third), without using additional disk space for the interface
+ files.
+
+
+Bug fixes
+---------
+
+Issues fixed (see [bug tracker](https://github.com/agda/agda/issues)):
+
+[#1546](https://github.com/agda/agda/issues/1546) (copattern matching
+and with-clauses)
+
+[#1560](https://github.com/agda/agda/issues/1560) (positivity checker
+inefficiency)
+
+[#1584](https://github.com/agda/agda/issues/1548) (let pattern with
+trailing implicit)
+
+Release notes for Agda version 2.4.2.3
+======================================
+
+Installation and infrastructure
+-------------------------------
+
+* Added support for GHC 7.10.1.
+
+* Removed support for GHC 7.0.4.
+
+Language
+--------
+
+* `_ `is no longer a valid name for a definition. The following fails
+ now: [Issue [#1465](https://github.com/agda/agda/issues/1465)]
+
+ ```agda
+ postulate _ : Set
+ ```
+
+* Typed bindings can now contain hiding information
+ [Issue [#1391](https://github.com/agda/agda/issues/1391)]. This
+ means you can now write
+
+ ```agda
+ assoc : (xs {ys zs} : List A) → ((xs ++ ys) ++ zs) ≡ (xs ++ (ys ++ zs))
+ ```
+
+ instead of the longer
+
+ ```agda
+ assoc : (xs : List A) {ys zs : List A} → ...
+ ```
+
+ It also works with irrelevance
+
+ ```agda
+ .(xs {ys zs} : List A) → ...
+ ```
+
+ but of course does not make sense if there is hiding information already.
+ Thus, this is (still) a parse error:
+
+ ```agda
+ {xs {ys zs} : List A} → ...
+ ```
+
+* The builtins for sized types no longer need accompanying postulates.
+ The BUILTIN pragmas for size stuff now also declare the identifiers
+ they bind to.
+
+ ```agda
+ {-# BUILTIN SIZEUNIV SizeUniv #-} -- SizeUniv : SizeUniv
+ {-# BUILTIN SIZE Size #-} -- Size : SizeUniv
+ {-# BUILTIN SIZELT Size<_ #-} -- Size<_ : ..Size → SizeUniv
+ {-# BUILTIN SIZESUC ↑_ #-} -- ↑_ : Size → Size
+ {-# BUILTIN SIZEINF ∞ #-} -- ∞ : Size
+ ```
+
+ `Size` and `Size<` now live in the new universe `SizeUniv`. It is
+ forbidden to build function spaces in this universe, in order to
+ prevent the malicious assumption of a size predecessor
+
+ ```agda
+ pred : (i : Size) → Size< i
+ ```
+
+ [Issue [#1428](https://github.com/agda/agda/issues/1428)].
+
+* Unambiguous notations (coming from syntax declarations) that resolve
+ to ambiguous names are now parsed unambiguously
+ [Issue [#1194](https://github.com/agda/agda/issues/1194)].
+
+* If only some instances of an overloaded name have a given associated
+ notation (coming from syntax declarations), then this name can only
+ be resolved to the given instances of the name, not to other
+ instances [Issue [#1194](https://github.com/agda/agda/issues/1194)].
+
+ Previously, if different instances of an overloaded name had
+ *different* associated notations, then none of the notations could
+ be used. Now all of them can be used.
+
+ Note that notation identity does not only involve the right-hand
+ side of the syntax declaration. For instance, the following
+ notations are not seen as identical, because the implicit argument
+ names are different:
+
+ ```agda
+ module A where
+
+ data D : Set where
+ c : {x y : D} → D
+
+ syntax c {x = a} {y = b} = a ∙ b
+
+ module B where
+
+ data D : Set where
+ c : {y x : D} → D
+
+ syntax c {y = a} {x = b} = a ∙ b
+ ```
+
+* If an overloaded operator is in scope with at least two distinct
+ fixities, then it gets the default fixity
+ [Issue [#1436](https://github.com/agda/agda/issues/1436)].
+
+ Similarly, if two or more identical notations for a given overloaded
+ name are in scope, and these notations do not all have the
+ same fixity, then they get the default fixity.
+
+Type checking
+-------------
+
+* Functions of varying arity can now have with-clauses and use rewrite.
+
+ Example:
+
+ ```agda
+ NPred : Nat → Set
+ NPred 0 = Bool
+ NPred (suc n) = Nat → NPred n
+
+ const : Bool → ∀{n} → NPred n
+ const b {0} = b
+ const b {suc n} m = const b {n}
+
+ allOdd : ∀ n → NPred n
+ allOdd 0 = true
+ allOdd (suc n) m with even m
+ ... | true = const false
+ ... | false = allOdd n
+ ```
+
+* Function defined by copattern matching can now have `with`-clauses
+ and use `rewrite`.
+
+ Example:
+
+ ```agda
+ {-# OPTIONS --copatterns #-}
+
+ record Stream (A : Set) : Set where
+ coinductive
+ constructor delay
+ field
+ force : A × Stream A
+ open Stream
+
+ map : ∀{A B} → (A → B) → Stream A → Stream B
+ force (map f s) with force s
+ ... | a , as = f a , map f as
+
+ record Bisim {A B} (R : A → B → Set) (s : Stream A) (t : Stream B) : Set where
+ coinductive
+ constructor ~delay
+ field
+ ~force : let a , as = force s
+ b , bs = force t
+ in R a b × Bisim R as bs
+ open Bisim
+
+ SEq : ∀{A} (s t : Stream A) → Set
+ SEq = Bisim (_≡_)
+
+ -- Slightly weird definition of symmetry to demonstrate rewrite.
+
+ ~sym' : ∀{A} {s t : Stream A} → SEq s t → SEq t s
+ ~force (~sym' {s = s} {t} p) with force s | force t | ~force p
+ ... | a , as | b , bs | r , q rewrite r = refl , ~sym' q
+ ```
+
+* Instances can now be defined by copattern
+ matching. [Issue [#1413](https://github.com/agda/agda/issues/1413)]
+ The following example extends the one in
+ [Abel, Pientka, Thibodeau, Setzer, POPL 2013, Section 2.2]:
+
+ ```agda
+ {-# OPTIONS --copatterns #-}
+
+ -- The Monad type class
+
+ record Monad (M : Set → Set) : Set1 where
+ field
+ return : {A : Set} → A → M A
+ _>>=_ : {A B : Set} → M A → (A → M B) → M B
+ open Monad {{...}}
+
+ -- The State newtype
+
+ record State (S A : Set) : Set where
+ field
+ runState : S → A × S
+ open State
+
+ -- State is an instance of Monad
+
+ instance
+ stateMonad : {S : Set} → Monad (State S)
+ runState (return {{stateMonad}} a ) s = a , s -- NEW
+ runState (_>>=_ {{stateMonad}} m k) s₀ = -- NEW
+ let a , s₁ = runState m s₀
+ in runState (k a) s₁
+
+ -- stateMonad fulfills the monad laws
+
+ leftId : {A B S : Set}(a : A)(k : A → State S B) →
+ (return a >>= k) ≡ k a
+ leftId a k = refl
+
+ rightId : {A B S : Set}(m : State S A) →
+ (m >>= return) ≡ m
+ rightId m = refl
+
+ assoc : {A B C S : Set}(m : State S A)(k : A → State S B)(l : B → State S C) →
+ ((m >>= k) >>= l) ≡ (m >>= λ a → k a >>= l)
+ assoc m k l = refl
+ ```
+
+Emacs mode
+----------
+
+* The new menu option `Switch to another version of Agda` tries to do
+ what it says.
+
+* Changed feature: Interactively split result.
+
+ [ This is as before: ]
+ Make-case (`C-c C-c`) with no variables given tries to split on the
+ result to introduce projection patterns. The hole needs to be of
+ record type, of course.
+
+ ```agda
+ test : {A B : Set} (a : A) (b : B) → A × B
+ test a b = ?
+ ```
+
+ Result-splitting `?` will produce the new clauses:
+
+ ```agda
+ proj₁ (test a b) = ?
+ proj₂ (test a b) = ?
+ ```
+
+ [ This has changed: ]
+ If hole is of function type, `make-case` will introduce only pattern
+ variables (as much as it can).
+
+ ```agda
+ testFun : {A B : Set} (a : A) (b : B) → A × B
+ testFun = ?
+ ```
+
+ Result-splitting `?` will produce the new clause:
+
+ ```agda
+ testFun a b = ?
+ ```
+
+ A second invocation of `make-case` will then introduce projection
+ patterns.
+
+Error messages
+--------------
+
+* Agda now suggests corrections of misspelled options, e.g.
+
+ ```agda
+ {-# OPTIONS
+ --dont-termination-check
+ --without-k
+ --senf-gurke
+ #-}
+ ```
+
+ Unrecognized options:
+
+ ```
+ --dont-termination-check (did you mean --no-termination-check ?)
+ --without-k (did you mean --without-K ?)
+ --senf-gurke
+ ```
+
+ Nothing close to `--senf-gurke`, I am afraid.
+
+Compiler backends
+-----------------
+
+* The Epic backend has been removed
+ [Issue [#1481](https://github.com/agda/agda/issues/1481)].
+
+Bug fixes
+---------
+
+* Fixed bug with `unquoteDecl` not working in instance blocks
+ [Issue [#1491](https://github.com/agda/agda/issues/1491)].
+
+* Other issues fixed (see
+ [bug tracker](https://github.com/agda/agda/issues)
+
+ [#1497](https://github.com/agda/agda/issues/1497)
+
+ [#1500](https://github.com/agda/agda/issues/1500)
+
+Release notes for Agda version 2.4.2.2
+======================================
+
+Bug fixes
+---------
+
+* Compilation on Windows fixed.
+
+* Other issues fixed (see
+ [bug tracker](https://github.com/agda/agda/issues))
+
+ [#1332](https://github.com/agda/agda/issues/1322)
+
+ [#1353](https://github.com/agda/agda/issues/1353)
+
+ [#1360](https://github.com/agda/agda/issues/1360)
+
+ [#1366](https://github.com/agda/agda/issues/1366)
+
+ [#1369](https://github.com/agda/agda/issues/1369)
+
+Release notes for Agda version 2.4.2.1
+======================================
+
+Pragmas and options
+-------------------
+
+* New pragma `{-# TERMINATING #-}` replacing
+ `{-# NO_TERMINATION_CHECK #-}`
+
+ Complements the existing pragma `{-# NON_TERMINATING #-}`. Skips
+ termination check for the associated definitions and marks them as
+ terminating. Thus, it is a replacement for `{-#
+ NO_TERMINATION_CHECK #-}` with the same semantics.
+
+ You can no longer use pragma `{-# NO_TERMINATION_CHECK #-}` to skip
+ the termination check, but must label your definitions as either
+ `{-# TERMINATING #-}` or `{-# NON_TERMINATING #-}` instead.
+
+ Note: `{-# OPTION --no-termination-check #-}` labels all your
+ definitions as `{-# TERMINATING #-}`, putting you in the danger zone
+ of a loop in the type checker.
+
+Language
+--------
+
+* Referring to a local variable shadowed by module opening is now an
+ error. Previous behavior was preferring the local over the imported
+ definitions. [Issue [#1266](https://github.com/agda/agda/issues/1266)]
+
+ Note that module parameters are locals as well as variables bound by
+ λ, dependent function type, patterns, and let.
+
+ Example:
+
+ ```agda
+ module M where
+ A = Set1
+
+ test : (A : Set) → let open M in A
+ ```
+
+ The last `A` produces an error, since it could refer to the local
+ variable `A` or to the definition imported from module `M`.
+
+* `with` on a variable bound by a module telescope or a pattern of a
+ parent function is now forbidden.
+ [Issue [#1342](https://github.com/agda/agda/issues/1342)]
+
+ ```agda
+ data Unit : Set where
+ unit : Unit
+
+ id : (A : Set) → A → A
+ id A a = a
+
+ module M (x : Unit) where
+
+ dx : Unit → Unit
+ dx unit = x
+
+ g : ∀ u → x ≡ dx u
+ g with x
+ g | unit = id (∀ u → unit ≡ dx u) ?
+ ```
+
+ Even though this code looks right, Agda complains about the type
+ expression `∀ u → unit ≡ dx u`. If you ask Agda what should go
+ there instead, it happily tells you that it wants `∀ u → unit ≡ dx
+ u`. In fact what you do not see and Agda will never show you is that
+ the two expressions actually differ in the invisible first argument
+ to `dx`, which is visible only outside module `M`. What Agda wants
+ is an invisible `unit` after `dx`, but all you can write is an
+ invisible `x` (which is inserted behind the scenes).
+
+ To avoid those kinds of paradoxes, `with` is now outlawed on module
+ parameters. This should ensure that the invisible arguments are
+ always exactly the module parameters.
+
+ Since a `where` block is desugared as module with pattern variables
+ of the parent clause as module parameters, the same strikes you for
+ uses of `with` on pattern variables of the parent function.
+
+ ```agda
+ f : Unit → Unit
+ f x = unit
+ where
+ dx : Unit → Unit
+ dx unit = x
+
+ g : ∀ u → x ≡ dx u
+ g with x
+ g | unit = id ((u : Unit) → unit ≡ dx u) ?
+ ```
+
+ The `with` on pattern variable `x` of the parent clause `f x = unit`
+ is outlawed now.
+
+Type checking
+-------------
+
+* Termination check failure is now a proper error.
+
+ We no longer continue type checking after termination check
+ failures. Use pragmas `{-# NON_TERMINATING #-}` and `{-#
+ NO_TERMINATION_CHECK #-}` near the offending definitions if you want
+ to do so. Or switch off the termination checker altogether with
+ `{-# OPTIONS --no-termination-check #-}` (at your own risk!).
+
+* (Since Agda 2.4.2): Termination checking `--without-K` restricts
+ structural descent to arguments ending in data types or `Size`.
+ Likewise, guardedness is only tracked when result type is data or
+ record type.
+
+ ```agda
+ mutual
+ data WOne : Set where wrap : FOne → WOne
+ FOne = ⊥ → WOne
+
+ noo : (X : Set) → (WOne ≡ X) → X → ⊥
+ noo .WOne refl (wrap f) = noo FOne iso f
+ ```
+
+ `noo` is rejected since at type `X` the structural descent
+ `f < wrap f` is discounted `--without-K`.
+
+ ```agda
+ data Pandora : Set where
+ C : ∞ ⊥ → Pandora
+
+ loop : (A : Set) → A ≡ Pandora → A
+ loop .Pandora refl = C (♯ (loop ⊥ foo))
+ ```
+
+ `loop` is rejected since guardedness is not tracked at type `A`
+ `--without-K`.
+
+ See issues [#1023](https://github.com/agda/agda/issues/1023),
+ [#1264](https://github.com/agda/agda/issues/1264),
+ [#1292](https://github.com/agda/agda/issues/1292).
+
+Termination checking
+--------------------
+
+* The termination checker can now recognize simple subterms in dot
+ patterns.
+
+ ```agda
+ data Subst : (d : Nat) → Set where
+ c₁ : ∀ {d} → Subst d → Subst d
+ c₂ : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (suc d₁ + d₂)
+
+ postulate
+ comp : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (d₁ + d₂)
+
+ lookup : ∀ d → Nat → Subst d → Set₁
+ lookup d zero (c₁ ρ) = Set
+ lookup d (suc v) (c₁ ρ) = lookup d v ρ
+ lookup .(suc d₁ + d₂) v (c₂ {d₁} {d₂} ρ σ) = lookup (d₁ + d₂) v (comp ρ σ)
+ ```
+
+ The dot pattern here is actually normalized, so it is
+
+ ```agda
+ suc (d₁ + d₂)
+ ```
+
+ and the corresponding recursive call argument is `(d₁ + d₂)`. In
+ such simple cases, Agda can now recognize that the pattern is
+ constructor applied to call argument, which is valid descent.
+
+ Note however, that Agda only looks for syntactic equality when
+ identifying subterms, since it is not allowed to normalize terms on
+ the rhs during termination checking.
+
+ Actually writing the dot pattern has no effect, this works as well,
+ and looks pretty magical... ;-)
+
+ ```agda
+ hidden : ∀{d} → Nat → Subst d → Set₁
+ hidden zero (c₁ ρ) = Set
+ hidden (suc v) (c₁ ρ) = hidden v ρ
+ hidden v (c₂ ρ σ) = hidden v (comp ρ σ)
+ ```
+
+Tools
+-----
+
+### LaTeX-backend
+
+* Fixed the issue of identifiers containing operators being typeset with
+ excessive math spacing.
+
+Bug fixes
+---------
+
+* Issue [#1194](https://github.com/agda/agda/issues/1194)
+
+* Issue [#836](https://github.com/agda/agda/issues/836): Fields and
+ constructors can be qualified by the record/data *type* as well as
+ by their record/data module. This now works also for record/data
+ type imported from parametrized modules:
+
+ ```agda
+ module M (_ : Set₁) where
+
+ record R : Set₁ where
+ field
+ X : Set
+
+ open M Set using (R) -- rather than using (module R)
+
+ X : R → Set
+ X = R.X
+ ```
+
+Release notes for Agda version 2.4.2
+====================================
+
+Pragmas and options
+-------------------
+
+* New option: `--with-K`
+
+ This can be used to override a global `--without-K` in a file, by
+ adding a pragma `{-# OPTIONS --with-K #-}`.
+
+* New pragma `{-# NON_TERMINATING #-}`
+
+ This is a safer version of `NO_TERMINATION_CHECK` which doesn't
+ treat the affected functions as terminating. This means that
+ `NON_TERMINATING` functions do not reduce during type checking. They
+ do reduce at run-time and when invoking `C-c C-n` at top-level (but
+ not in a hole).
+
+Language
+--------
+
+* Instance search is now more efficient and recursive (see
+ Issue [#938](https://github.com/agda/agda/issues/938)) (but without
+ termination check yet).
+
+ A new keyword `instance` has been introduced (in the style of
+ `abstract` and `private`) which must now be used for every
+ definition/postulate that has to be taken into account during
+ instance resolution. For example:
+
+ ```agda
+ record RawMonoid (A : Set) : Set where
+ field
+ nil : A
+ _++_ : A -> A -> A
+
+ open RawMonoid {{...}}
+
+ instance
+ rawMonoidList : {A : Set} -> RawMonoid (List A)
+ rawMonoidList = record { nil = []; _++_ = List._++_ }
+
+ rawMonoidMaybe : {A : Set} {{m : RawMonoid A}} -> RawMonoid (Maybe A)
+ rawMonoidMaybe {A} = record { nil = nothing ; _++_ = catMaybe }
+ where
+ catMaybe : Maybe A -> Maybe A -> Maybe A
+ catMaybe nothing mb = mb
+ catMaybe ma nothing = ma
+ catMaybe (just a) (just b) = just (a ++ b)
+ ```
+
+ Moreover, each type of an instance must end in (something that reduces
+ to) a named type (e.g. a record, a datatype or a postulate). This
+ allows us to build a simple index structure
+
+ ```
+ data/record name --> possible instances
+ ```
+
+ that speeds up instance search.
+
+ Instance search takes into account all local bindings and all global
+ `instance` bindings and the search is recursive. For instance,
+ searching for
+
+ ```agda
+ ? : RawMonoid (Maybe (List A))
+ ```
+
+ will consider the candidates {`rawMonoidList`, `rawMonoidMaybe`}, fail to
+ unify the first one, succeeding with the second one
+
+ ```agda
+ ? = rawMonoidMaybe {A = List A} {{m = ?m}} : RawMonoid (Maybe (List A))
+ ```
+
+ and continue with goal
+
+ ```agda
+ ?m : RawMonoid (List A)
+ ```
+
+ This will then find
+
+ ```agda
+ ?m = rawMonoidList {A = A}
+ ```
+
+ and putting together we have the solution.
+
+ Be careful that there is no termination check for now, you can
+ easily make Agda loop by declaring the identity function as an
+ instance. But it shouldn’t be possible to make Agda loop by only
+ declaring structurally recursive instances (whatever that means).
+
+ Additionally:
+
+ - Uniqueness of instances is up to definitional equality (see
+ Issue [#899](https://github.com/agda/agda/issues/899)).
+
+ - Instances of the following form are allowed:
+
+ ```agda
+ EqSigma : {A : Set} {B : A → Set} {{EqA : Eq A}}
+ {{EqB : {a : A} → Eq (B a)}}
+ → Eq (Σ A B)
+ ```
+
+ When searching recursively for an instance of type `{a : A} → Eq
+ (B a)`, a lambda will automatically be introduced and instance
+ search will search for something of type `Eq (B a)` in the context
+ extended by `a : A`. When searching for an instance, the `a`
+ argument does not have to be implicit, but in the definition of
+ `EqSigma`, instance search will only be able to use `EqB` if `a`
+ is implicit.
+
+ - There is no longer any attempt to solve irrelevant metas by instance
+ search.
+
+ - Constructors of records and datatypes are automatically added to the
+ instance table.
+
+* You can now use `quote` in patterns.
+
+ For instance, here is a function that unquotes a (closed) natural
+ number term.
+
+ ```agda
+ unquoteNat : Term → Maybe Nat
+ unquoteNat (con (quote Nat.zero) []) = just zero
+ unquoteNat (con (quote Nat.suc) (arg _ n ∷ [])) = fmap suc (unquoteNat n)
+ unquoteNat _ = nothing
+ ```
+
+* The builtin constructors `AGDATERMUNSUPPORTED` and
+ `AGDASORTUNSUPPORTED` are now translated to meta variables when
+ unquoting.
+
+* New syntactic sugar `tactic e` and `tactic e | e1 | .. | en`.
+
+ It desugars as follows and makes it less unwieldy to call
+ reflection-based tactics.
+
+ ```agda
+ tactic e --> quoteGoal g in unquote (e g)
+ tactic e | e1 | .. | en --> quoteGoal g in unquote (e g) e1 .. en
+ ```
+
+ Note that in the second form the tactic function should generate a
+ function from a number of new subgoals to the original goal. The
+ type of `e` should be `Term -> Term` in both cases.
+
+* New reflection builtins for literals.
+
+ The term data type `AGDATERM` now needs an additional constructor
+ `AGDATERMLIT` taking a reflected literal defined as follows (with
+ appropriate builtin bindings for the types `Nat`, `Float`, etc).
+
+ ```agda
+ data Literal : Set where
+ nat : Nat → Literal
+ float : Float → Literal
+ char : Char → Literal
+ string : String → Literal
+ qname : QName → Literal
+
+ {-# BUILTIN AGDALITERAL Literal #-}
+ {-# BUILTIN AGDALITNAT nat #-}
+ {-# BUILTIN AGDALITFLOAT float #-}
+ {-# BUILTIN AGDALITCHAR char #-}
+ {-# BUILTIN AGDALITSTRING string #-}
+ {-# BUILTIN AGDALITQNAME qname #-}
+ ```
+
+ When quoting (`quoteGoal` or `quoteTerm`) literals will be mapped to
+ the `AGDATERMLIT` constructor. Previously natural number literals
+ were quoted to `suc`/`zero` application and other literals were
+ quoted to `AGDATERMUNSUPPORTED`.
+
+* New reflection builtins for function definitions.
+
+ `AGDAFUNDEF` should now map to a data type defined as follows
+
+ (with
+ ```agda
+ {-# BUILTIN QNAME QName #-}
+ {-# BUILTIN ARG Arg #-}
+ {-# BUILTIN AGDATERM Term #-}
+ {-# BUILTIN AGDATYPE Type #-}
+ {-# BUILTIN AGDALITERAL Literal #-}
+ ```
+ ).
+
+ ```agda
+ data Pattern : Set where
+ con : QName → List (Arg Pattern) → Pattern
+ dot : Pattern
+ var : Pattern
+ lit : Literal → Pattern
+ proj : QName → Pattern
+ absurd : Pattern
+
+ {-# BUILTIN AGDAPATTERN Pattern #-}
+ {-# BUILTIN AGDAPATCON con #-}
+ {-# BUILTIN AGDAPATDOT dot #-}
+ {-# BUILTIN AGDAPATVAR var #-}
+ {-# BUILTIN AGDAPATLIT lit #-}
+ {-# BUILTIN AGDAPATPROJ proj #-}
+ {-# BUILTIN AGDAPATABSURD absurd #-}
+
+ data Clause : Set where
+ clause : List (Arg Pattern) → Term → Clause
+ absurd-clause : List (Arg Pattern) → Clause
+
+ {-# BUILTIN AGDACLAUSE Clause #-}
+ {-# BUILTIN AGDACLAUSECLAUSE clause #-}
+ {-# BUILTIN AGDACLAUSEABSURD absurd-clause #-}
+
+ data FunDef : Set where
+ fun-def : Type → List Clause → FunDef
+
+ {-# BUILTIN AGDAFUNDEF FunDef #-}
+ {-# BUILTIN AGDAFUNDEFCON fun-def #-}
+ ```
+
+* New reflection builtins for extended (pattern-matching) lambda.
+
+ The `AGDATERM` data type has been augmented with a constructor
+
+ ```agda
+ AGDATERMEXTLAM : List AGDACLAUSE → List (ARG AGDATERM) → AGDATERM
+ ```
+
+ Absurd lambdas (`λ ()`) are quoted to extended lambdas with an
+ absurd clause.
+
+* Unquoting declarations.
+
+ You can now define (recursive) functions by reflection using the new
+ `unquoteDecl` declaration
+
+ ```agda
+ unquoteDecl x = e
+ ```
+
+ Here e should have type `AGDAFUNDEF` and evaluate to a closed
+ value. This value is then spliced in as the definition of `x`. In
+ the body `e`, `x` has type `QNAME` which lets you splice in
+ recursive definitions.
+
+ Standard modifiers, such as fixity declarations, can be applied to `x` as
+ expected.
+
+* Quoted levels
+
+ Universe levels are now quoted properly instead of being quoted to
+ `AGDASORTUNSUPPORTED`. `Setω` still gets an unsupported sort,
+ however.
+
+* Module applicants can now be operator applications.
+
+ Example:
+
+ ```agda
+ postulate
+ [_] : A -> B
+
+ module M (b : B) where
+
+ module N (a : A) = M [ a ]
+ ```
+
+ [See Issue [#1245](https://github.com/agda/agda/issues/1245)]
+
+* Minor change in module application
+ semantics. [Issue [#892](https://github.com/agda/agda/issues/892)]
+
+ Previously re-exported functions were not redefined when
+ instantiating a module. For instance
+
+ ```agda
+ module A where f = ...
+ module B (X : Set) where
+ open A public
+ module C = B Nat
+ ```
+
+ In this example `C.f` would be an alias for `A.f`, so if both `A`
+ and `C` were opened `f` would not be ambiguous. However, this
+ behaviour is not correct when `A` and `B` share some module
+ parameters
+ (Issue [#892](https://github.com/agda/agda/issues/892)). To fix this
+ `C` now defines its own copy of `f` (which evaluates to `A.f`),
+ which means that opening `A` and `C` results in an ambiguous `f`.
+
+Type checking
+-------------
+
+* Recursive records need to be declared as either `inductive` or
+ `coinductive`. `inductive` is no longer default for recursive
+ records. Examples:
+
+ ```agda
+ record _×_ (A B : Set) : Set where
+ constructor _,_
+ field
+ fst : A
+ snd : B
+
+ record Tree (A : Set) : Set where
+ inductive
+ constructor tree
+ field
+ elem : A
+ subtrees : List (Tree A)
+
+ record Stream (A : Set) : Set where
+ coinductive
+ constructor _::_
+ field
+ head : A
+ tail : Stream A
+ ```
+
+ If you are using old-style (musical) coinduction, a record may have
+ to be declared as inductive, paradoxically.
+
+ ```agda
+ record Stream (A : Set) : Set where
+ inductive -- YES, THIS IS INTENDED !
+ constructor _∷_
+ field
+ head : A
+ tail : ∞ (Stream A)
+ ```
+
+ This is because the "coinduction" happens in the use of `∞` and not
+ in the use of `record`.
+
+Tools
+-----
+
+### Emacs mode
+
+* A new menu option `Display` can be used to display the version of
+ the running Agda process.
+
+### LaTeX-backend
+
+* New experimental option `references` has been added. When specified,
+ i.e.:
+
+ ```latex
+ \usepackage[references]{agda}
+ ```
+
+ a new command called `\AgdaRef` is provided, which lets you
+ reference previously typeset commands, e.g.:
+
+ Let us postulate `\AgdaRef{apa}`.
+
+ ```agda
+ \begin{code}
+ postulate
+ apa : Set
+ \end{code}
+ ```
+
+ Above `apa` will be typeset (highlighted) the same in the text as in
+ the code, provided that the LaTeX output is post-processed using
+ `src/data/postprocess-latex.pl`, e.g.:
+
+ ```
+ cp $(dirname $(dirname $(agda-mode locate)))/postprocess-latex.pl .
+ agda -i. --latex Example.lagda
+ cd latex/
+ perl ../postprocess-latex.pl Example.tex > Example.processed
+ mv Example.processed Example.tex
+ xelatex Example.tex
+ ```
+
+ Mix-fix and Unicode should work as expected (Unicode requires
+ XeLaTeX/LuaLaTeX), but there are limitations:
+
+ - Overloading identifiers should be avoided, if multiples exist
+ `\AgdaRef` will typeset according to the first it finds.
+
+ - Only the current module is used, should you need to reference
+ identifiers in other modules then you need to specify which other
+ module manually, i.e. `\AgdaRef[module]{identifier}`.
+
+Release notes for Agda 2 version 2.4.0.2
+========================================
+
+* The Agda input mode now supports alphabetical super and subscripts,
+ in addition to the numerical ones that were already present.
+ [Issue [#1240](https://github.com/agda/agda/issues/1240)]
+
+* New feature: Interactively split result.
+
+ Make case (`C-c C-c`) with no variables given tries to split on the
+ result to introduce projection patterns. The hole needs to be of
+ record type, of course.
+
+ ```agda
+ test : {A B : Set} (a : A) (b : B) → A × B
+ test a b = ?
+ ```
+
+ Result-splitting `?` will produce the new clauses:
+
+ ```agda
+ proj₁ (test a b) = ?
+ proj₂ (test a b) = ?
+ ```
+
+ If hole is of function type ending in a record type, the necessary
+ pattern variables will be introduced before the split. Thus, the
+ same result can be obtained by starting from:
+
+ ```agda
+ test : {A B : Set} (a : A) (b : B) → A × B
+ test = ?
+ ```
+
+* The so far undocumented `ETA` pragma now throws an error if applied to
+ definitions that are not records.
+
+ `ETA` can be used to force eta-equality at recursive record types,
+ for which eta is not enabled automatically by Agda. Here is such an
+ example:
+
+ ```agda
+ mutual
+ data Colist (A : Set) : Set where
+ [] : Colist A
+ _∷_ : A → ∞Colist A → Colist A
+
+ record ∞Colist (A : Set) : Set where
+ coinductive
+ constructor delay
+ field force : Colist A
+
+ open ∞Colist
+
+ {-# ETA ∞Colist #-}
+
+ test : {A : Set} (x : ∞Colist A) → x ≡ delay (force x)
+ test x = refl
+ ```
+
+ Note: Unsafe use of `ETA` can make Agda loop, e.g. by triggering
+ infinite eta expansion!
+
+* Bugs fixed (see [bug tracker](https://github.com/agda/agda/issues)):
+
+ [#1203](https://github.com/agda/agda/issues/1203)
+
+ [#1205](https://github.com/agda/agda/issues/1205)
+
+ [#1209](https://github.com/agda/agda/issues/1209)
+
+ [#1213](https://github.com/agda/agda/issues/1213)
+
+ [#1214](https://github.com/agda/agda/issues/1214)
+
+ [#1216](https://github.com/agda/agda/issues/1216)
+
+ [#1225](https://github.com/agda/agda/issues/1225)
+
+ [#1226](https://github.com/agda/agda/issues/1226)
+
+ [#1231](https://github.com/agda/agda/issues/1231)
+
+ [#1233](https://github.com/agda/agda/issues/1233)
+
+ [#1239](https://github.com/agda/agda/issues/1239)
+
+ [#1241](https://github.com/agda/agda/issues/1241)
+
+ [#1243](https://github.com/agda/agda/issues/1243)
+
+Release notes for Agda 2 version 2.4.0.1
+========================================
+
+* The option `--compile-no-main` has been renamed to `--no-main`.
+
+* `COMPILED_DATA` pragmas can now be given for records.
+
+* Various bug fixes.
+
+Release notes for Agda 2 version 2.4.0
+======================================
+
+Installation and infrastructure
+-------------------------------
+
+* A new module called `Agda.Primitive` has been introduced. This
+ module is available to all users, even if the standard library is
+ not used. Currently the module contains level primitives and their
+ representation in Haskell when compiling with MAlonzo:
+
+ ```agda
+ infixl 6 _⊔_
+
+ postulate
+ Level : Set
+ lzero : Level
+ lsuc : (ℓ : Level) → Level
+ _⊔_ : (ℓ₁ ℓ₂ : Level) → Level
+
+ {-# COMPILED_TYPE Level () #-}
+ {-# COMPILED lzero () #-}
+ {-# COMPILED lsuc (\_ -> ()) #-}
+ {-# COMPILED _⊔_ (\_ _ -> ()) #-}
+
+ {-# BUILTIN LEVEL Level #-}
+ {-# BUILTIN LEVELZERO lzero #-}
+ {-# BUILTIN LEVELSUC lsuc #-}
+ {-# BUILTIN LEVELMAX _⊔_ #-}
+ ```
+
+ To bring these declarations into scope you can use a declaration
+ like the following one:
+
+ ```agda
+ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
+ ```
+
+ The standard library reexports these primitives (using the names
+ `zero` and `suc` instead of `lzero` and `lsuc`) from the `Level`
+ module.
+
+ Existing developments using universe polymorphism might now trigger
+ the following error message:
+
+ ```
+ Duplicate binding for built-in thing LEVEL, previous binding to
+ .Agda.Primitive.Level
+ ```
+
+ To fix this problem, please remove the duplicate bindings.
+
+ Technical details (perhaps relevant to those who build Agda
+ packages):
+
+ The include path now always contains a directory
+ `<DATADIR>/lib/prim`, and this directory is supposed to contain a
+ subdirectory Agda containing a file `Primitive.agda`.
+
+ The standard location of `<DATADIR>` is system- and
+ installation-specific. E.g., in a Cabal `--user` installation of
+ Agda-2.3.4 on a standard single-ghc Linux system it would be
+ `$HOME/.cabal/share/Agda-2.3.4` or something similar.
+
+ The location of the `<DATADIR>` directory can be configured at
+ compile-time using Cabal flags (`--datadir` and `--datasubdir`).
+ The location can also be set at run-time, using the `Agda_datadir`
+ environment variable.
+
+Pragmas and options
+-------------------
+
+* Pragma `NO_TERMINATION_CHECK` placed within a mutual block is now
+ applied to the whole mutual block (rather than being discarded
+ silently). Adding to the uses 1.-4. outlined in the release notes
+ for 2.3.2 we allow:
+
+ 3a. Skipping an old-style mutual block: Somewhere within `mutual`
+ block before a type signature or first function clause.
+
+ ```agda
+ mutual
+ {-# NO_TERMINATION_CHECK #-}
+ c : A
+ c = d
+
+ d : A
+ d = c
+ ```
+
+* New option `--no-pattern-matching`
+
+ Disables all forms of pattern matching (for the current file).
+ You can still import files that use pattern matching.
+
+* New option `-v profile:7`
+
+ Prints some stats on which phases Agda spends how much time.
+ (Number might not be very reliable, due to garbage collection
+ interruptions, and maybe due to laziness of Haskell.)
+
+* New option `--no-sized-types`
+
+ Option `--sized-types` is now default. `--no-sized-types` will turn
+ off an extra (inexpensive) analysis on data types used for subtyping
+ of sized types.
+
+Language
+--------
+
+* Experimental feature: `quoteContext`
+
+ There is a new keyword `quoteContext` that gives users access to the
+ list of names in the current local context. For instance:
+
+ ```agda
+ open import Data.Nat
+ open import Data.List
+ open import Reflection
+
+ foo : ℕ → ℕ → ℕ
+ foo 0 m = 0
+ foo (suc n) m = quoteContext xs in ?
+ ```
+
+ In the remaining goal, the list `xs` will consist of two names, `n`
+ and `m`, corresponding to the two local variables. At the moment it
+ is not possible to access let bound variables (this feature may be
+ added in the future).
+
+* Experimental feature: Varying arity.
+ Function clauses may now have different arity, e.g.,
+
+ ```agda
+ Sum : ℕ → Set
+ Sum 0 = ℕ
+ Sum (suc n) = ℕ → Sum n
+
+ sum : (n : ℕ) → ℕ → Sum n
+ sum 0 acc = acc
+ sum (suc n) acc m = sum n (m + acc)
+ ```
+
+ or,
+
+ ```agda
+ T : Bool → Set
+ T true = Bool
+ T false = Bool → Bool
+
+ f : (b : Bool) → T b
+ f false true = false
+ f false false = true
+ f true = true
+ ```
+
+ This feature is experimental. Yet unsupported:
+ - Varying arity and `with`.
+
+ - Compilation of functions with varying arity to Haskell, JS, or Epic.
+
+* Experimental feature: copatterns. (Activated with option `--copatterns`)
+
+ We can now define a record by explaining what happens if you project
+ the record. For instance:
+
+ ```agda
+ {-# OPTIONS --copatterns #-}
+
+ record _×_ (A B : Set) : Set where
+ constructor _,_
+ field
+ fst : A
+ snd : B
+ open _×_
+
+ pair : {A B : Set} → A → B → A × B
+ fst (pair a b) = a
+ snd (pair a b) = b
+
+ swap : {A B : Set} → A × B → B × A
+ fst (swap p) = snd p
+ snd (swap p) = fst p
+
+ swap3 : {A B C : Set} → A × (B × C) → C × (B × A)
+ fst (swap3 t) = snd (snd t)
+ fst (snd (swap3 t)) = fst (snd t)
+ snd (snd (swap3 t)) = fst t
+ ```
+
+ Taking a projection on the left hand side (lhs) is called a
+ projection pattern, applying to a pattern is called an application
+ pattern. (Alternative terms: projection/application copattern.)
+
+ In the first example, the symbol `pair`, if applied to variable
+ patterns `a` and `b` and then projected via `fst`, reduces to
+ `a`. `pair` by itself does not reduce.
+
+ A typical application are coinductive records such as streams:
+
+ ```agda
+ record Stream (A : Set) : Set where
+ coinductive
+ field
+ head : A
+ tail : Stream A
+ open Stream
+
+ repeat : {A : Set} (a : A) -> Stream A
+ head (repeat a) = a
+ tail (repeat a) = repeat a
+ ```
+
+ Again, `repeat a` by itself will not reduce, but you can take a
+ projection (head or tail) and then it will reduce to the respective
+ rhs. This way, we get the lazy reduction behavior necessary to
+ avoid looping corecursive programs.
+
+ Application patterns do not need to be trivial (i.e., variable
+ patterns), if we mix with projection patterns. E.g., we can have
+
+ ```agda
+ nats : Nat -> Stream Nat
+ head (nats zero) = zero
+ tail (nats zero) = nats zero
+ head (nats (suc x)) = x
+ tail (nats (suc x)) = nats x
+ ```
+
+ Here is an example (not involving coinduction) which demostrates
+ records with fields of function type:
+
+ ```agda
+ -- The State monad
+
+ record State (S A : Set) : Set where
+ constructor state
+ field
+ runState : S → A × S
+ open State
+
+ -- The Monad type class
+
+ record Monad (M : Set → Set) : Set1 where
+ constructor monad
+ field
+ return : {A : Set} → A → M A
+ _>>=_ : {A B : Set} → M A → (A → M B) → M B
+
+
+ -- State is an instance of Monad
+ -- Demonstrates the interleaving of projection and application patterns
+
+ stateMonad : {S : Set} → Monad (State S)
+ runState (Monad.return stateMonad a ) s = a , s
+ runState (Monad._>>=_ stateMonad m k) s₀ =
+ let a , s₁ = runState m s₀
+ in runState (k a) s₁
+
+ module MonadLawsForState {S : Set} where
+
+ open Monad (stateMonad {S})
+
+ leftId : {A B : Set}(a : A)(k : A → State S B) →
+ (return a >>= k) ≡ k a
+ leftId a k = refl
+
+ rightId : {A B : Set}(m : State S A) →
+ (m >>= return) ≡ m
+ rightId m = refl
+
+ assoc : {A B C : Set}(m : State S A)(k : A → State S B)(l : B → State S C) →
+ ((m >>= k) >>= l) ≡ (m >>= λ a → (k a >>= l))
+ assoc m k l = refl
+ ```
+
+ Copatterns are yet experimental and the following does not work:
+
+ - Copatterns and `with` clauses.
+
+ - Compilation of copatterns to Haskell, JS, or Epic.
+
+ - Projections generated by
+
+ ```agda
+ open R {{...}}
+ ```
+
+ are not handled properly on lhss yet.
+
+ - Conversion checking is slower in the presence of copatterns, since
+ stuck definitions of record type do no longer count as neutral,
+ since they can become unstuck by applying a projection. Thus,
+ comparing two neutrals currently requires comparing all they
+ projections, which repeats a lot of work.
+
+* Top-level module no longer required.
+
+ The top-level module can be omitted from an Agda file. The module
+ name is then inferred from the file name by dropping the path and
+ the `.agda` extension. So, a module defined in `/A/B/C.agda` would get
+ the name `C`.
+
+ You can also suppress only the module name of the top-level module
+ by writing
+
+ ```agda
+ module _ where
+ ```
+
+ This works also for parameterised modules.
+
+* Module parameters are now always hidden arguments in projections.
+ For instance:
+
+ ```agda
+ module M (A : Set) where
+
+ record Prod (B : Set) : Set where
+ constructor _,_
+ field
+ fst : A
+ snd : B
+ open Prod public
+
+ open M
+ ```
+
+ Now, the types of `fst` and `snd` are
+
+ ```agda
+ fst : {A : Set}{B : Set} → Prod A B → A
+ snd : {A : Set}{B : Set} → Prod A B → B
+ ```
+
+ Until 2.3.2, they were
+
+ ```agda
+ fst : (A : Set){B : Set} → Prod A B → A
+ snd : (A : Set){B : Set} → Prod A B → B
+ ```
+
+ This change is a step towards symmetry of constructors and projections.
+ (Constructors always took the module parameters as hidden arguments).
+
+* Telescoping lets: Local bindings are now accepted in telescopes
+ of modules, function types, and lambda-abstractions.
+
+ The syntax of telescopes as been extended to support `let`:
+
+ ```agda
+ id : (let ★ = Set) (A : ★) → A → A
+ id A x = x
+ ```
+
+ In particular one can now `open` modules inside telescopes:
+
+ ```agda
+ module Star where
+ ★ : Set₁
+ ★ = Set
+
+
+ module MEndo (let open Star) (A : ★) where
+ Endo : ★
+ Endo = A → A
+ ```
+
+ Finally a shortcut is provided for opening modules:
+
+ ```agda
+ module N (open Star) (A : ★) (open MEndo A) (f : Endo) where
+ ...
+ ```
+
+ The semantics of the latter is
+
+ ```agda
+ module _ where
+ open Star
+ module _ (A : ★) where
+ open MEndo A
+ module N (f : Endo) where
+ ...
+ ```
+
+ The semantics of telescoping lets in function types and lambda
+ abstractions is just expanding them into ordinary lets.
+
+* More liberal left-hand sides in lets
+ [Issue [#1028](https://github.com/agda/agda/issues/1028)]:
+
+ You can now write left-hand sides with arguments also for let
+ bindings without a type signature. For instance,
+
+ ```agda
+ let f x = suc x in f zero
+ ```
+
+ Let bound functions still can't do pattern matching though.
+
+* Ambiguous names in patterns are now optimistically resolved in favor
+ of constructors. [Issue [#822](https://github.com/agda/agda/issues/822)]
+ In particular, the following succeeds now:
+
+ ```agda
+ module M where
+
+ data D : Set₁ where
+ [_] : Set → D
+
+ postulate [_] : Set → Set
+
+ open M
+
+ Foo : _ → Set
+ Foo [ A ] = A
+ ```
+
+* Anonymous `where`-modules are opened
+ public. [Issue [#848](https://github.com/agda/agda/issues/848)]
+
+ ```
+ <clauses>
+ f args = rhs
+ module _ telescope where
+ body
+ <more clauses>
+ ```
+
+ means the following (not proper Agda code, since you cannot put a
+ module in-between clauses)
+
+ ```
+ <clauses>
+ module _ {arg-telescope} telescope where
+ body
+
+ f args = rhs
+ <more clauses>
+ ```
+
+ Example:
+
+ ```agda
+ A : Set1
+ A = B module _ where
+ B : Set1
+ B = Set
+
+ C : Set1
+ C = B
+ ```
+
+* Builtin `ZERO` and `SUC` have been merged with `NATURAL`.
+
+ When binding the `NATURAL` builtin, `ZERO` and `SUC` are bound to
+ the appropriate constructors automatically. This means that instead
+ of writing
+
+ ```agda
+ {-# BUILTIN NATURAL Nat #-}
+ {-# BUILTIN ZERO zero #-}
+ {-# BUILTIN SUC suc #-}
+ ```
+
+ you just write
+
+ ```agda
+ {-# BUILTIN NATURAL Nat #-}
+ ```
+
+* Pattern synonym can now have implicit
+ arguments. [Issue [#860](https://github.com/agda/agda/issues/860)]
+
+ For example,
+
+ ```agda
+ pattern tail=_ {x} xs = x ∷ xs
+
+ len : ∀ {A} → List A → Nat
+ len [] = 0
+ len (tail= xs) = 1 + len xs
+ ```
+
+* Syntax declarations can now have implicit
+ arguments. [Issue [#400](https://github.com/agda/agda/issues/400)]
+
+ For example
+
+ ```agda
+ id : ∀ {a}{A : Set a} -> A -> A
+ id x = x
+
+ syntax id {A} x = x ∈ A
+ ```
+
+* Minor syntax changes
+
+ - `-}` is now parsed as end-comment even if no comment was begun. As
+ a consequence, the following definition gives a parse error
+
+ ```agda
+ f : {A- : Set} -> Set
+ f {A-} = A-
+ ```
+
+ because Agda now sees `ID(f) LBRACE ID(A) END-COMMENT`, and no
+ longer `ID(f) LBRACE ID(A-) RBRACE`.
+
+ The rational is that the previous lexing was to context-sensitive,
+ attempting to comment-out `f` using `{-` and `-}` lead to a parse
+ error.
+
+ - Fixities (binding strengths) can now be negative numbers as
+ well. [Issue [#1109](https://github.com/agda/agda/issues/1109)]
+
+ ```agda
+ infix -1 _myop_
+ ```
+
+ - Postulates are now allowed in mutual
+ blocks. [Issue [#977](https://github.com/agda/agda/issues/977)]
+
+ - Empty where blocks are now
+ allowed. [Issue [#947](https://github.com/agda/agda/issues/947)]
+
+ - Pattern synonyms are now allowed in parameterised
+ modules. [Issue [#941](https://github.com/agda/agda/issues/941)]
+
+ - Empty hiding and renaming lists in module directives are now allowed.
+
+ - Module directives `using`, `hiding`, `renaming` and `public` can
+ now appear in arbitrary order. Multiple
+ `using`/`hiding`/`renaming` directives are allowed, but you still
+ cannot have both using and `hiding` (because that doesn't make
+ sense). [Issue [#493](https://github.com/agda/agda/issues/493)]
+
+Goal and error display
+----------------------
+
+* The error message `Refuse to construct infinite term` has been
+ removed, instead one gets unsolved meta variables. Reason: the
+ error was thrown over-eagerly.
+ [Issue [#795](https://github.com/agda/agda/issues/795)]
+
+* If an interactive case split fails with message
+
+ ```
+ Since goal is solved, further case distinction is not supported;
+ try `Solve constraints' instead
+ ```
+
+ then the associated interaction meta is assigned to a solution.
+ Press `C-c C-=` (Show constraints) to view the solution and `C-c
+ C-s` (Solve constraints) to apply it.
+ [Issue [#289](https://github.com/agda/agda/issues/289)]
+
+Type checking
+-------------
+
+* [ Issue [#376](https://github.com/agda/agda/issues/376) ]
+ Implemented expansion of bound record variables during meta
+ assignment. Now Agda can solve for metas X that are applied to
+ projected variables, e.g.:
+
+ ```agda
+ X (fst z) (snd z) = z
+
+ X (fst z) = fst z
+ ```
+
+ Technically, this is realized by substituting `(x , y)` for `z` with fresh
+ bound variables `x` and `y`. Here the full code for the examples:
+
+ ```agda
+ record Sigma (A : Set)(B : A -> Set) : Set where
+ constructor _,_
+ field
+ fst : A
+ snd : B fst
+ open Sigma
+
+ test : (A : Set) (B : A -> Set) ->
+ let X : (x : A) (y : B x) -> Sigma A B
+ X = _
+ in (z : Sigma A B) -> X (fst z) (snd z) ≡ z
+ test A B z = refl
+
+ test' : (A : Set) (B : A -> Set) ->
+ let X : A -> A
+ X = _
+ in (z : Sigma A B) -> X (fst z) ≡ fst z
+ test' A B z = refl
+ ```
+
+ The fresh bound variables are named `fst(z)` and `snd(z)` and can appear
+ in error messages, e.g.:
+
+ ```agda
+ fail : (A : Set) (B : A -> Set) ->
+ let X : A -> Sigma A B
+ X = _
+ in (z : Sigma A B) -> X (fst z) ≡ z
+ fail A B z = refl
+ ```
+
+ results in error:
+
+ ```
+ Cannot instantiate the metavariable _7 to solution fst(z) , snd(z)
+ since it contains the variable snd(z) which is not in scope of the
+ metavariable or irrelevant in the metavariable but relevant in the
+ solution
+ when checking that the expression refl has type _7 A B (fst z) ≡ z
+ ```
+
+* Dependent record types and definitions by copatterns require
+ reduction with previous function clauses while checking the current
+ clause. [Issue [#907](https://github.com/agda/agda/issues/907)]
+
+ For a simple example, consider
+
+ ```agda
+ test : ∀ {A} → Σ Nat λ n → Vec A n
+ proj₁ test = zero
+ proj₂ test = []
+ ```
+
+ For the second clause, the lhs and rhs are typed as
+
+ ```agda
+ proj₂ test : Vec A (proj₁ test)
+ [] : Vec A zero
+ ```
+
+ In order for these types to match, we have to reduce the lhs type
+ with the first function clause.
+
+ Note that termination checking comes after type checking, so be
+ careful to avoid non-termination! Otherwise, the type checker
+ might get into an infinite loop.
+
+* The implementation of the primitive `primTrustMe` has changed. It
+ now only reduces to `REFL` if the two arguments `x` and `y` have the
+ same computational normal form. Before, it reduced when `x` and `y`
+ were definitionally equal, which included type-directed equality
+ laws such as eta-equality. Yet because reduction is untyped,
+ calling conversion from reduction lead to Agda crashes
+ [Issue [#882](https://github.com/agda/agda/issues/882)].
+
+ The amended description of `primTrustMe` is (cf. release notes
+ for 2.2.6):
+
+ ```agda
+ primTrustMe : {A : Set} {x y : A} → x ≡ y
+ ```
+
+ Here `_≡_` is the builtin equality (see BUILTIN hooks for equality,
+ above).
+
+ If `x` and `y` have the same computational normal form, then
+ `primTrustMe {x = x} {y = y}` reduces to `refl`.
+
+ A note on `primTrustMe`'s runtime behavior: The MAlonzo compiler
+ replaces all uses of `primTrustMe` with the `REFL` builtin, without
+ any check for definitional equality. Incorrect uses of `primTrustMe`
+ can potentially lead to segfaults or similar problems of the
+ compiled code.
+
+* Implicit patterns of record type are now only eta-expanded if there
+ is a record constructor.
+ [Issues [#473](https://github.com/agda/agda/issues/473),
+ [#635](https://github.com/agda/agda/issues/635)]
+
+ ```agda
+ data D : Set where
+ d : D
+
+ data P : D → Set where
+ p : P d
+
+ record Rc : Set where
+ constructor c
+ field f : D
+
+ works : {r : Rc} → P (Rc.f r) → Set
+ works p = D
+ ```
+
+ This works since the implicit pattern `r` is eta-expanded to `c x`
+ which allows the type of `p` to reduce to `P x` and `x` to be
+ unified with `d`. The corresponding explicit version is:
+
+ ```agda
+ works' : (r : Rc) → P (Rc.f r) → Set
+ works' (c .d) p = D
+ ```
+
+ However, if the record constructor is removed, the same example will
+ fail:
+
+ ```agda
+ record R : Set where
+ field f : D
+
+ fails : {r : R} → P (R.f r) → Set
+ fails p = D
+
+ -- d != R.f r of type D
+ -- when checking that the pattern p has type P (R.f r)
+ ```
+
+ The error is justified since there is no pattern we could write down
+ for `r`. It would have to look like
+
+ ```agda
+ record { f = .d }
+ ```
+
+ but anonymous record patterns are not part of the language.
+
+* Absurd lambdas at different source locations are no longer
+ different. [Issue [#857](https://github.com/agda/agda/issues/857)]
+ In particular, the following code type-checks now:
+
+ ```agda
+ absurd-equality : _≡_ {A = ⊥ → ⊥} (λ()) λ()
+ absurd-equality = refl
+ ```
+
+ Which is a good thing!
+
+* Printing of named implicit function types.
+
+ When printing terms in a context with bound variables Agda renames
+ new bindings to avoid clashes with the previously bound names. For
+ instance, if `A` is in scope, the type `(A : Set) → A` is printed as
+ `(A₁ : Set) → A₁`. However, for implicit function types the name of
+ the binding matters, since it can be used when giving implicit
+ arguments.
+
+ For this situation, the following new syntax has been introduced:
+ `{x = y : A} → B` is an implicit function type whose bound variable
+ (in scope in `B`) is `y`, but where the name of the argument is `x`
+ for the purposes of giving it explicitly. For instance, with `A` in
+ scope, the type `{A : Set} → A` is now printed as `{A = A₁ : Set} →
+ A₁`.
+
+ This syntax is only used when printing and is currently not being parsed.
+
+* Changed the semantics of `--without-K`.
+ [Issue [#712](https://github.com/agda/agda/issues/712),
+ Issue [#865](https://github.com/agda/agda/issues/865),
+ Issue [#1025](https://github.com/agda/agda/issues/1025)]
+
+ New specification of `--without-K`:
+
+ When `--without-K` is enabled, the unification of indices for
+ pattern matching is restricted in two ways:
+
+ 1. Reflexive equations of the form `x == x` are no longer solved,
+ instead Agda gives an error when such an equation is encountered.
+
+ 2. When unifying two same-headed constructor forms `c us` and `c vs`
+ of type `D pars ixs`, the datatype indices `ixs` (but not the
+ parameters) have to be *self-unifiable*, i.e. unification of
+ `ixs` with itself should succeed positively. This is a nontrivial
+ requirement because of point 1.
+
+ Examples:
+
+ - The J rule is accepted.
+
+ ```agda
+ J : {A : Set} (P : {x y : A} → x ≡ y → Set) →
+ (∀ x → P (refl x)) →
+ ∀ {x y} (x≡y : x ≡ y) → P x≡y
+ J P p (refl x) = p x
+ ```agda
+
+ This definition is accepted since unification of `x` with `y`
+ doesn't require deletion or injectivity.
+
+ - The K rule is rejected.
+
+ ```agda
+ K : {A : Set} (P : {x : A} → x ≡ x → Set) →
+ (∀ x → P (refl {x = x})) →
+ ∀ {x} (x≡x : x ≡ x) → P x≡x
+ K P p refl = p _
+ ```
+
+ Definition is rejected with the following error:
+
+ ```
+ Cannot eliminate reflexive equation x = x of type A because K has
+ been disabled.
+ when checking that the pattern refl has type x ≡ x
+ ```
+
+ - Symmetry of the new criterion.
+
+ ```agda
+ test₁ : {k l m : ℕ} → k + l ≡ m → ℕ
+ test₁ refl = zero
+
+ test₂ : {k l m : ℕ} → k ≡ l + m → ℕ
+ test₂ refl = zero
+ ```
+
+ Both versions are now accepted (previously only the first one was).
+
+ - Handling of parameters.
+
+ ```agda
+ cons-injective : {A : Set} (x y : A) → (x ∷ []) ≡ (y ∷ []) → x ≡ y
+ cons-injective x .x refl = refl
+ ```
+
+ Parameters are not unified, so they are ignored by the new criterion.
+
+ - A larger example: antisymmetry of ≤.
+
+ ```agda
+ data _≤_ : ℕ → ℕ → Set where
+ lz : (n : ℕ) → zero ≤ n
+ ls : (m n : ℕ) → m ≤ n → suc m ≤ suc n
+
+ ≤-antisym : (m n : ℕ) → m ≤ n → n ≤ m → m ≡ n
+ ≤-antisym .zero .zero (lz .zero) (lz .zero) = refl
+ ≤-antisym .(suc m) .(suc n) (ls m n p) (ls .n .m q) =
+ cong suc (≤-antisym m n p q)
+ ```
+
+ - [ Issue [#1025](https://github.com/agda/agda/issues/1025) ]
+
+ ```agda
+ postulate mySpace : Set
+ postulate myPoint : mySpace
+
+ data Foo : myPoint ≡ myPoint → Set where
+ foo : Foo refl
+
+ test : (i : foo ≡ foo) → i ≡ refl
+ test refl = {!!}
+ ```
+
+ When applying injectivity to the equation `foo ≡ foo` of type `Foo
+ refl`, it is checked that the index `refl` of type `myPoint ≡
+ myPoint` is self-unifiable. The equation `refl ≡ refl` again
+ requires injectivity, so now the index `myPoint` is checked for
+ self-unifiability, hence the error:
+
+ ```
+ Cannot eliminate reflexive equation myPoint = myPoint of type
+ mySpace because K has been disabled.
+ when checking that the pattern refl has type foo ≡ foo
+ ```
+
+Termination checking
+--------------------
+
+* A buggy facility coined "matrix-shaped orders" that supported
+ uncurried functions (which take tuples of arguments instead of one
+ argument after another) has been removed from the termination
+ checker. [Issue [#787](https://github.com/agda/agda/issues/787)]
+
+* Definitions which fail the termination checker are not unfolded any
+ longer to avoid loops or stack overflows in Agda. However, the
+ termination checker for a mutual block is only invoked after
+ type-checking, so there can still be loops if you define a
+ non-terminating function. But termination checking now happens
+ before the other supplementary checks: positivity, polarity,
+ injectivity and projection-likeness. Note that with the pragma `{-#
+ NO_TERMINATION_CHECK #-}` you can make Agda treat any function as
+ terminating.
+
+* Termination checking of functions defined by `with` has been improved.
+
+ Cases which previously required `--termination-depth` to pass the
+ termination checker (due to use of `with`) no longer need the
+ flag. For example
+
+ ```agda
+ merge : List A → List A → List A
+ merge [] ys = ys
+ merge xs [] = xs
+ merge (x ∷ xs) (y ∷ ys) with x ≤ y
+ merge (x ∷ xs) (y ∷ ys) | false = y ∷ merge (x ∷ xs) ys
+ merge (x ∷ xs) (y ∷ ys) | true = x ∷ merge xs (y ∷ ys)
+ ```
+
+ This failed to termination check previously, since the `with`
+ expands to an auxiliary function `merge-aux`:
+
+ ```agda
+ merge-aux x y xs ys false = y ∷ merge (x ∷ xs) ys
+ merge-aux x y xs ys true = x ∷ merge xs (y ∷ ys)
+ ```
+
+ This function makes a call to `merge` in which the size of one of
+ the arguments is increasing. To make this pass the termination
+ checker now inlines the definition of `merge-aux` before checking,
+ thus effectively termination checking the original source program.
+
+ As a result of this transformation doing `with` on a variable no longer
+ preserves termination. For instance, this does not termination check:
+
+ ```agda
+ bad : Nat → Nat
+ bad n with n
+ ... | zero = zero
+ ... | suc m = bad m
+ ```
+
+* The performance of the termination checker has been improved. For
+ higher `--termination-depth` the improvement is significant. While
+ the default `--termination-depth` is still 1, checking with higher
+ `--termination-depth` should now be feasible.
+
+Compiler backends
+-----------------
+
+* The MAlonzo compiler backend now has support for compiling modules
+ that are not full programs (i.e. don't have a main function). The
+ goal is that you can write part of a program in Agda and the rest in
+ Haskell, and invoke the Agda functions from the Haskell code. The
+ following features were added for this reason:
+
+ - A new command-line option `--compile-no-main`: the command
+
+ ```
+ agda --compile-no-main Test.agda
+ ```
+
+ will compile `Test.agda` and all its dependencies to Haskell and
+ compile the resulting Haskell files with `--make`, but (unlike
+ `--compile`) not tell GHC to treat `Test.hs` as the main
+ module. This type of compilation can be invoked from Emacs by
+ customizing the `agda2-backend` variable to value `MAlonzoNoMain` and
+ then calling `C-c C-x C-c` as before.
+
+ - A new pragma `COMPILED_EXPORT` was added as part of the MAlonzo
+ FFI. If we have an Agda file containing the following:
+
+ ```agda
+ module A.B where
+
+ test : SomeType
+ test = someImplementation
+
+ {-# COMPILED_EXPORT test someHaskellId #-}
+ ```
+
+ then test will be compiled to a Haskell function called
+ `someHaskellId` in module `MAlonzo.Code.A.B` that can be invoked
+ from other Haskell code. Its type will be translated according to
+ the normal MAlonzo rules.
+
+Tools
+-----
+
+### Emacs mode
+
+* A new goal command `Helper Function Type` (`C-c C-h`) has been added.
+
+ If you write an application of an undefined function in a goal, the
+ `Helper Function Type` command will print the type that the function
+ needs to have in order for it to fit the goal. The type is also
+ added to the Emacs kill-ring and can be pasted into the buffer using
+ `C-y`.
+
+ The application must be of the form `f args` where `f` is the name of the
+ helper function you want to create. The arguments can use all the normal
+ features like named implicits or instance arguments.
+
+ Example:
+
+ Here's a start on a naive reverse on vectors:
+
+ ```agda
+ reverse : ∀ {A n} → Vec A n → Vec A n
+ reverse [] = []
+ reverse (x ∷ xs) = {!snoc (reverse xs) x!}
+ ```
+
+ Calling `C-c C-h` in the goal prints
+
+ ```agda
+ snoc : ∀ {A} {n} → Vec A n → A → Vec A (suc n)
+ ```
+
+* A new command `Explain why a particular name is in scope` (`C-c
+ C-w`) has been added.
+ [Issue [#207](https://github.com/agda/agda/issues/207)]
+
+ This command can be called from a goal or from the top-level and will as the
+ name suggests explain why a particular name is in scope.
+
+ For each definition or module that the given name can refer to a trace is
+ printed of all open statements and module applications leading back to the
+ original definition of the name.
+
+ For example, given
+
+ ```agda
+ module A (X : Set₁) where
+ data Foo : Set where
+ mkFoo : Foo
+ module B (Y : Set₁) where
+ open A Y public
+ module C = B Set
+ open C
+ ```
+
+ Calling `C-c C-w` on `mkFoo` at the top-level prints
+
+ ```
+ mkFoo is in scope as
+ * a constructor Issue207.C._.Foo.mkFoo brought into scope by
+ - the opening of C at Issue207.agda:13,6-7
+ - the application of B at Issue207.agda:11,12-13
+ - the application of A at Issue207.agda:9,8-9
+ - its definition at Issue207.agda:6,5-10
+ ```
+
+ This command is useful if Agda complains about an ambiguous name and
+ you need to figure out how to hide the undesired interpretations.
+
+* Improvements to the `make case` command (`C-c C-c`)
+
+ - One can now also split on hidden variables, using the name
+ (starting with `.`) with which they are printed. Use `C-c C-`, to
+ see all variables in context.
+
+ - Concerning the printing of generated clauses:
+
+ * Uses named implicit arguments to improve readability.
+
+ * Picks explicit occurrences over implicit ones when there is a
+ choice of binding site for a variable.
+
+ * Avoids binding variables in implicit positions by replacing dot
+ patterns that uses them by wildcards (`._`).
+
+* Key bindings for lots of "mathematical" characters (examples: 𝐴𝑨𝒜𝓐𝔄)
+ have been added to the Agda input method. Example: type
+ `\MiA\MIA\McA\MCA\MfA` to get 𝐴𝑨𝒜𝓐𝔄.
+
+ Note: `\McB` does not exist in Unicode (as well as others in that style),
+ but the `\MC` (bold) alphabet is complete.
+
+* Key bindings for "blackboard bold" B (𝔹) and 0-9 (𝟘-𝟡) have been
+ added to the Agda input method (`\bb` and `\b[0-9]`).
+
+* Key bindings for controlling simplification/normalisation:
+
+ [TODO: Simplification should be explained somewhere.]
+
+ Commands like `Goal type and context` (`C-c C-,`) could previously
+ be invoked in two ways. By default the output was normalised, but if
+ a prefix argument was used (for instance via `C-u C-c C-,`), then no
+ explicit normalisation was performed. Now there are three options:
+
+ - By default (`C-c C-,`) the output is simplified.
+
+ - If `C-u` is used exactly once (`C-u C-c C-,`), then the result is
+ neither (explicitly) normalised nor simplified.
+
+ - If `C-u` is used twice (`C-u C-u C-c C-,`), then the result is
+ normalised.
+
+ [TODO: As part of the release of Agda 2.3.4 the key binding page on
+ the wiki should be updated.]
+
+### LaTeX-backend
+
+* Two new color scheme options were added to `agda.sty`:
+
+ `\usepackage[bw]{agda}`, which highlights in black and white;
+ `\usepackage[conor]{agda}`, which highlights using Conor's colors.
+
+ The default (no options passed) is to use the standard colors.
+
+* If `agda.sty` cannot be found by the LateX environment, it is now
+ copied into the LateX output directory (`latex` by default) instead
+ of the working directory. This means that the commands needed to
+ produce a PDF now is
+
+ ```
+ agda --latex -i . <file>.lagda
+ cd latex
+ pdflatex <file>.tex
+ ```
+
+* The LaTeX-backend has been made more tool agnostic, in particular
+ XeLaTeX and LuaLaTeX should now work. Here is a small example
+ (`test/LaTeXAndHTML/succeed/UnicodeInput.lagda`):
+
+ ```latex
+ \documentclass{article}
+ \usepackage{agda}
+ \begin{document}
+
+ \begin{code}
+ data αβγδεζθικλμνξρστυφχψω : Set₁ where
+
+ postulate
+ →⇒⇛⇉⇄↦⇨↠⇀⇁ : Set
+ \end{code}
+
+ \[
+ ∀X [ ∅ ∉ X ⇒ ∃f:X ⟶ ⋃ X\ ∀A ∈ X (f(A) ∈ A) ]
+ \]
+ \end{document}
+ ```
+
+ Compiled as follows, it should produce a nice looking PDF (tested with
+ TeX Live 2012):
+
+ ```
+ agda --latex <file>.lagda
+ cd latex
+ xelatex <file>.tex (or lualatex <file>.tex)
+ ```
+
+ If symbols are missing or XeLaTeX/LuaLaTeX complains about the font
+ missing, try setting a different font using:
+
+ ```latex
+ \setmathfont{<math-font>}
+ ```
+
+ Use the `fc-list` tool to list available fonts.
+
+* Add experimental support for hyperlinks to identifiers
+
+ If the `hyperref` LateX package is loaded before the Agda package
+ and the links option is passed to the Agda package, then the Agda
+ package provides a function called `\AgdaTarget`. Identifiers which
+ have been declared targets, by the user, will become clickable
+ hyperlinks in the rest of the document. Here is a small example
+ (`test/LaTeXAndHTML/succeed/Links.lagda`):
+
+ ```latex
+ \documentclass{article}
+ \usepackage{hyperref}
+ \usepackage[links]{agda}
+ \begin{document}
+
+ \AgdaTarget{ℕ}
+ \AgdaTarget{zero}
+ \begin{code}
+ data ℕ : Set where
+ zero : ℕ
+ suc : ℕ → ℕ
+ \end{code}
+
+ See next page for how to define \AgdaFunction{two} (doesn't turn into a
+ link because the target hasn't been defined yet). We could do it
+ manually though; \hyperlink{two}{\AgdaDatatype{two}}.
+
+ \newpage
+
+ \AgdaTarget{two}
+ \hypertarget{two}{}
+ \begin{code}
+ two : ℕ
+ two = suc (suc zero)
+ \end{code}
+
+ \AgdaInductiveConstructor{zero} is of type
+ \AgdaDatatype{ℕ}. \AgdaInductiveConstructor{suc} has not been defined to
+ be a target so it doesn't turn into a link.
+
+ \newpage
+
+ Now that the target for \AgdaFunction{two} has been defined the link
+ works automatically.
+
+ \begin{code}
+ data Bool : Set where
+ true false : Bool
+ \end{code}
+
+ The AgdaTarget command takes a list as input, enabling several
+ targets to be specified as follows:
+
+ \AgdaTarget{if, then, else, if\_then\_else\_}
+ \begin{code}
+ if_then_else_ : {A : Set} → Bool → A → A → A
+ if true then t else f = t
+ if false then t else f = f
+ \end{code}
+
+ \newpage
+
+ Mixfix identifier need their underscores escaped:
+ \AgdaFunction{if\_then\_else\_}.
+
+ \end{document}
+ ```
+
+ The boarders around the links can be suppressed using hyperref's
+ hidelinks option:
+
+ ```latex
+ \usepackage[hidelinks]{hyperref}
+ ```
+
+ Note that the current approach to links does not keep track of scoping
+ or types, and hence overloaded names might create links which point to
+ the wrong place. Therefore it is recommended to not overload names
+ when using the links option at the moment, this might get fixed in the
+ future.
+
+Release notes for Agda 2 version 2.3.2.2
+========================================
+
+* Fixed a bug that sometimes made it tricky to use the Emacs mode on
+ Windows [Issue [#757](https://github.com/agda/agda/issues/757)].
+
+* Made Agda build with newer versions of some libraries.
+
+* Fixed a bug that caused ambiguous parse error messages
+ [Issue [#147](https://github.com/agda/agda/issues/147)].
+
+Release notes for Agda 2 version 2.3.2.1
+========================================
+
+Installation
+------------
+
+* Made it possible to compile Agda with more recent versions of
+ hashable, QuickCheck and Win32.
+
+* Excluded mtl-2.1.
+
+Type checking
+-------------
+
+* Fixed bug in the termination checker
+ (Issue [#754](https://github.com/agda/agda/issues/754)).
+
+Release notes for Agda 2 version 2.3.2
+======================================
+
+Installation
+------------
+
+* The Agda-executable package has been removed.
+
+ The executable is now provided as part of the Agda package.
+
+* The Emacs mode no longer depends on haskell-mode or GHCi.
+
+* Compilation of Emacs mode Lisp files.
+
+ You can now compile the Emacs mode Lisp files by running `agda-mode
+ compile`. This command is run by `make install`.
+
+ Compilation can, in some cases, give a noticeable speedup.
+
+ WARNING: If you reinstall the Agda mode without recompiling the
+ Emacs Lisp files, then Emacs may continue using the old, compiled
+ files.
+
+Pragmas and options
+-------------------
+
+* The `--without-K` check now reconstructs constructor parameters.
+
+ New specification of `--without-K`:
+
+ If the flag is activated, then Agda only accepts certain
+ case-splits. If the type of the variable to be split is
+ `D pars ixs`, where `D` is a data (or record) type, `pars` stands
+ for the parameters, and `ixs` the indices, then the following
+ requirements must be satisfied:
+
+ - The indices `ixs` must be applications of constructors (or
+ literals) to distinct variables. Constructors are usually not
+ applied to parameters, but for the purposes of this check
+ constructor parameters are treated as other arguments.
+
+ - These distinct variables must not be free in pars.
+
+* Irrelevant arguments are printed as `_` by default now. To turn on
+ printing of irrelevant arguments, use option
+
+ ```
+ --show-irrelevant
+ ```
+
+* New: Pragma `NO_TERMINATION_CHECK` to switch off termination checker
+ for individual function definitions and mutual blocks.
+
+ The pragma must precede a function definition or a mutual block.
+ Examples (see `test/Succeed/NoTerminationCheck.agda`):
+
+ 1. Skipping a single definition: before type signature.
+
+ ```agda
+ {-# NO_TERMINATION_CHECK #-}
+ a : A
+ a = a
+ ```
+
+ 2. Skipping a single definition: before first clause.
+
+ ```agda
+ b : A
+ {-# NO_TERMINATION_CHECK #-}
+ b = b
+ ```
+
+ 3. Skipping an old-style mutual block: Before `mutual` keyword.
+
+ ```agda
+ {-# NO_TERMINATION_CHECK #-}
+ mutual
+ c : A
+ c = d
+
+ d : A
+ d = c
+ ```
+
+ 4. Skipping a new-style mutual block: Anywhere before a type
+ signature or first function clause in the block
+
+ ```agda
+ i : A
+ j : A
+
+ i = j
+ {-# NO_TERMINATION_CHECK #-}
+ j = i
+ ```
+
+ The pragma cannot be used in `--safe` mode.
+
+Language
+--------
+
+* Let binding record patterns
+
+ ```agda
+ record _×_ (A B : Set) : Set where
+ constructor _,_
+ field
+ fst : A
+ snd : B
+ open _×_
+
+ let (x , (y , z)) = t
+ in u
+ ```
+
+ will now be interpreted as
+
+ ```agda
+ let x = fst t
+ y = fst (snd t)
+ z = snd (snd t)
+ in u
+ ```
+
+ Note that the type of `t` needs to be inferable. If you need to
+ provide a type signature, you can write the following:
+
+ ```agda
+ let a : ...
+ a = t
+ (x , (y , z)) = a
+ in u
+ ```
+
+* Pattern synonyms
+
+ A pattern synonym is a declaration that can be used on the left hand
+ side (when pattern matching) as well as the right hand side (in
+ expressions). For example:
+
+ ```agda
+ pattern z = zero
+ pattern ss x = suc (suc x)
+
+ f : ℕ -> ℕ
+ f z = z
+ f (suc z) = ss z
+ f (ss n) = n
+ ```
+
+ Pattern synonyms are implemented by substitution on the abstract
+ syntax, so definitions are scope-checked but not type-checked. They
+ are particularly useful for universe constructions.
+
+* Qualified mixfix operators
+
+ It is now possible to use a qualified mixfix operator by qualifying
+ the first part of the name. For instance
+
+ ```agda
+ import Data.Nat as Nat
+ import Data.Bool as Bool
+
+ two = Bool.if true then 1 Nat.+ 1 else 0
+ ```
+
+* Sections [Issue [#735](https://github.com/agda/agda/issues/735)].
+ Agda now parses anonymous modules as sections:
+
+ ```agda
+ module _ {a} (A : Set a) where
+
+ data List : Set a where
+ [] : List
+ _∷_ : (x : A) (xs : List) → List
+
+ module _ {a} {A : Set a} where
+
+ _++_ : List A → List A → List A
+ [] ++ ys = ys
+ (x ∷ xs) ++ ys = x ∷ (xs ++ ys)
+
+ test : List Nat
+ test = (5 ∷ []) ++ (3 ∷ [])
+ ```
+
+ In general, now the syntax
+
+ ```agda
+ module _ parameters where
+ declarations
+ ```
+
+ is accepted and has the same effect as
+
+ ```agda
+ private
+ module M parameters where
+ declarations
+ open M public
+ ```
+
+ for a fresh name `M`.
+
+* Instantiating a module in an open import statement
+ [Issue [#481](https://github.com/agda/agda/issues/481)]. Now
+ accepted:
+
+ ```agda
+ open import Path.Module args [using/hiding/renaming (...)]
+ ```
+
+ This only brings the imported identifiers from `Path.Module` into scope,
+ not the module itself! Consequently, the following is pointless, and raises
+ an error:
+
+ ```agda
+ import Path.Module args [using/hiding/renaming (...)]
+ ```
+
+ You can give a private name `M` to the instantiated module via
+
+ ```agda
+ import Path.Module args as M [using/hiding/renaming (...)]
+ open import Path.Module args as M [using/hiding/renaming (...)]
+ ```
+
+ Try to avoid `as` as part of the arguments. `as` is not a keyword;
+ the following can be legal, although slightly obfuscated Agda code:
+
+ ```agda
+ open import as as as as as as
+ ```
+
+* Implicit module parameters can be given by name. E.g.
+
+ ```agda
+ open M {namedArg = bla}
+ ```
+
+ This feature has been introduced in Agda 2.3.0 already.
+
+* Multiple type signatures sharing a same type can now be written as a single
+ type signature.
+
+ ```agda
+ one two : ℕ
+ one = suc zero
+ two = suc one
+ ```
+
+Goal and error display
+----------------------
+
+* Meta-variables that were introduced by hidden argument `arg` are now
+ printed as `_arg_number` instead of just `_number`.
+ [Issue [#526](https://github.com/agda/agda/issues/526)]
+
+* Agda expands identifiers in anonymous modules when printing. Should
+ make some goals nicer to read.
+ [Issue [#721](https://github.com/agda/agda/issues/721)]
+
+* When a module identifier is ambiguous, Agda tells you if one of them
+ is a data type module.
+ [Issues [#318](https://github.com/agda/agda/issues/318),
+ [#705](https://github.com/agda/agda/issues/705)]
+
+Type checking
+-------------
+
+* Improved coverage checker. The coverage checker splits on arguments
+ that have constructor or literal pattern, committing to the
+ left-most split that makes progress. Consider the lookup function
+ for vectors:
+
+ ```agda
+ data Fin : Nat → Set where
+ zero : {n : Nat} → Fin (suc n)
+ suc : {n : Nat} → Fin n → Fin (suc n)
+
+ data Vec (A : Set) : Nat → Set where
+ [] : Vec A zero
+ _∷_ : {n : Nat} → A → Vec A n → Vec A (suc n)
+
+ _!!_ : {A : Set}{n : Nat} → Vec A n → Fin n → A
+ (x ∷ xs) !! zero = x
+ (x ∷ xs) !! suc i = xs !! i
+ ```
+
+ In Agda up to 2.3.0, this definition is rejected unless we add
+ an absurd clause
+
+ ```agda
+ [] !! ()
+ ```
+
+ This is because the coverage checker committed on splitting on the
+ vector argument, even though this inevitably lead to failed
+ coverage, because a case for the empty vector `[]` is missing.
+
+ The improvement to the coverage checker consists on committing only
+ on splits that have a chance of covering, since all possible
+ constructor patterns are present. Thus, Agda will now split first
+ on the `Fin` argument, since cases for both `zero` and `suc` are
+ present. Then, it can split on the `Vec` argument, since the empty
+ vector is already ruled out by instantiating `n` to a `suc _`.
+
+* Instance arguments resolution will now consider candidates which
+ still expect hidden arguments. For example:
+
+ ```agda
+ record Eq (A : Set) : Set where
+ field eq : A → A → Bool
+
+ open Eq {{...}}
+
+ eqFin : {n : ℕ} → Eq (Fin n)
+ eqFin = record { eq = primEqFin }
+
+ testFin : Bool
+ testFin = eq fin1 fin2
+ ```
+
+ The type-checker will now resolve the instance argument of the `eq`
+ function to `eqFin {_}`. This is only done for hidden arguments, not
+ instance arguments, so that the instance search stays non-recursive.
+
+* Constraint solving: Upgraded Miller patterns to record patterns.
+ [Issue [#456](https://github.com/agda/agda/issues/456)]
+
+ Agda now solves meta-variables that are applied to record patterns.
+ A typical (but here, artificial) case is:
+
+ ```agda
+ record Sigma (A : Set)(B : A -> Set) : Set where
+ constructor _,_
+ field
+ fst : A
+ snd : B fst
+
+ test : (A : Set)(B : A -> Set) ->
+ let X : Sigma A B -> Sigma A B
+ X = _
+ in (x : A)(y : B x) -> X (x , y) ≡ (x , y)
+ test A B x y = refl
+ ```
+
+ This yields a constraint of the form
+
+ ```
+ _X A B (x , y) := t[x,y]
+ ```
+
+ (with `t[x,y] = (x, y)`) which is not a Miller pattern.
+ However, Agda now solves this as
+
+ ```
+ _X A B z := t[fst z,snd z].
+ ```
+
+* Changed: solving recursive constraints.
+ [Issue [#585](https://github.com/agda/agda/issues/585)]
+
+ Until 2.3.0, Agda sometimes inferred values that did not pass the
+ termination checker later, or would even make Agda loop. To prevent
+ this, the occurs check now also looks into the definitions of the
+ current mutual block, to avoid constructing recursive solutions. As
+ a consequence, also terminating recursive solutions are no longer
+ found automatically.
+
+ This effects a programming pattern where the recursively computed
+ type of a recursive function is left to Agda to solve.
+
+ ```agda
+ mutual
+
+ T : D -> Set
+ T pattern1 = _
+ T pattern2 = _
+
+ f : (d : D) -> T d
+ f pattern1 = rhs1
+ f pattern2 = rhs2
+ ```
+
+ This might no longer work from now on. See examples
+ `test/Fail/Issue585*.agda`.
+
+* Less eager introduction of implicit parameters.
+ [Issue [#679](https://github.com/agda/agda/issues/679)]
+
+ Until Agda 2.3.0, trailing hidden parameters were introduced eagerly
+ on the left hand side of a definition. For instance, one could not
+ write
+
+ ```agda
+ test : {A : Set} -> Set
+ test = \ {A} -> A
+ ```
+
+ because internally, the hidden argument `{A : Set}` was added to the
+ left-hand side, yielding
+
+ ```agda
+ test {_} = \ {A} -> A
+ ```
+
+ which raised a type error. Now, Agda only introduces the trailing
+ implicit parameters it has to, in order to maintain uniform function
+ arity. For instance, in
+
+ ```agda
+ test : Bool -> {A B C : Set} -> Set
+ test true {A} = A
+ test false {B = B} = B
+ ```
+
+ Agda will introduce parameters `A` and `B` in all clauses, but not
+ `C`, resulting in
+
+ ```agda
+ test : Bool -> {A B C : Set} -> Set
+ test true {A} {_} = A
+ test false {_} {B = B} = B
+ ```
+
+ Note that for checking `where`-clauses, still all hidden trailing
+ parameters are in scope. For instance:
+
+ ```agda
+ id : {i : Level}{A : Set i} -> A -> A
+ id = myId
+ where myId : forall {A} -> A -> A
+ myId x = x
+ ```
+
+ To be able to fill in the meta variable `_1` in
+
+ ```agda
+ myId : {A : Set _1} -> A -> A
+ ```
+
+ the hidden parameter `{i : Level}` needs to be in scope.
+
+ As a result of this more lazy introduction of implicit parameters,
+ the following code now passes.
+
+ ```agda
+ data Unit : Set where
+ unit : Unit
+
+ T : Unit → Set
+ T unit = {u : Unit} → Unit
+
+ test : (u : Unit) → T u
+ test unit with unit
+ ... | _ = λ {v} → v
+ ```
+
+ Before, Agda would eagerly introduce the hidden parameter `{v}` as
+ unnamed left-hand side parameter, leaving no way to refer to it.
+
+ The related Issue [#655](https://github.com/agda/agda/issues/655)
+ has also been addressed. It is now possible to make `synonym'
+ definitions
+
+ ```
+ name = expression
+ ```
+
+ even when the type of expression begins with a hidden quantifier.
+ Simple example:
+
+ ```
+ id2 = id
+ ```
+
+ That resulted in unsolved metas until 2.3.0.
+
+* Agda detects unused arguments and ignores them during equality
+ checking. [Issue [#691](https://github.com/agda/agda/issues/691),
+ solves also Issue [#44](https://github.com/agda/agda/issues/44)]
+
+ Agda's polarity checker now assigns 'Nonvariant' to arguments that
+ are not actually used (except for absurd matches). If `f`'s first
+ argument is Nonvariant, then `f x` is definitionally equal to `f y`
+ regardless of `x` and `y`. It is similar to irrelevance, but does
+ not require user annotation.
+
+ For instance, unused module parameters do no longer get in the way:
+
+ ```agda
+ module M (x : Bool) where
+
+ not : Bool → Bool
+ not true = false
+ not false = true
+
+ open M true
+ open M false renaming (not to not′)
+
+ test : (y : Bool) → not y ≡ not′ y
+ test y = refl
+ ```
+
+ Matching against record or absurd patterns does not count as `use',
+ so we get some form of proof irrelevance:
+
+ ```agda
+ data ⊥ : Set where
+ record ⊤ : Set where
+ constructor trivial
+
+ data Bool : Set where
+ true false : Bool
+
+ True : Bool → Set
+ True true = ⊤
+ True false = ⊥
+
+ fun : (b : Bool) → True b → Bool
+ fun true trivial = true
+ fun false ()
+
+ test : (b : Bool) → (x y : True b) → fun b x ≡ fun b y
+ test b x y = refl
+ ```
+
+ More examples in `test/Succeed/NonvariantPolarity.agda`.
+
+ Phantom arguments: Parameters of record and data types are considered
+ `used' even if they are not actually used. Consider:
+
+ ```agda
+ False : Nat → Set
+ False zero = ⊥
+ False (suc n) = False n
+
+ module Invariant where
+ record Bla (n : Nat)(p : False n) : Set where
+
+ module Nonvariant where
+ Bla : (n : Nat) → False n → Set
+ Bla n p = ⊤
+ ```
+
+ Even though record `Bla` does not use its parameters `n` and `p`,
+ they are considered as used, allowing "phantom type" techniques.
+
+ In contrast, the arguments of function `Bla` are recognized as
+ unused. The following code type-checks if we open `Invariant` but
+ leaves unsolved metas if we open `Nonvariant`.
+
+ ```agda
+ drop-suc : {n : Nat}{p : False n} → Bla (suc n) p → Bla n p
+ drop-suc _ = _
+
+ bla : (n : Nat) → {p : False n} → Bla n p → ⊥
+ bla zero {()} b
+ bla (suc n) b = bla n (drop-suc b)
+ ```
+
+ If `Bla` is considered invariant, the hidden argument in the
+ recursive call can be inferred to be `p`. If it is considered
+ non-variant, then `Bla n X = Bla n p` does not entail `X = p` and
+ the hidden argument remains unsolved. Since `bla` does not actually
+ use its hidden argument, its value is not important and it could be
+ searched for. Unfortunately, polarity analysis of `bla` happens
+ only after type checking, thus, the information that `bla` is
+ non-variant in `p` is not available yet when meta-variables are
+ solved. (See
+ `test/Fail/BrokenInferenceDueToNonvariantPolarity.agda`)
+
+* Agda now expands simple definitions (one clause, terminating) to
+ check whether a function is constructor
+ headed. [Issue [#747](https://github.com/agda/agda/issues/747)] For
+ instance, the following now also works:
+
+ ```agda
+ MyPair : Set -> Set -> Set
+ MyPair A B = Pair A B
+
+ Vec : Set -> Nat -> Set
+ Vec A zero = Unit
+ Vec A (suc n) = MyPair A (Vec A n)
+ ```
+
+ Here, `Unit` and `Pair` are data or record types.
+
+Compiler backends
+-----------------
+
+* `-Werror` is now overridable.
+
+ To enable compilation of Haskell modules containing warnings, the
+ `-Werror` flag for the MAlonzo backend has been made
+ overridable. If, for example, `--ghc-flag=-Wwarn` is passed when
+ compiling, one can get away with things like:
+
+ ```agda
+ data PartialBool : Set where
+ true : PartialBool
+
+ {-# COMPILED_DATA PartialBool Bool True #-}
+ ```
+
+ The default behavior remains as it used to be and rejects the above
+ program.
+
+Tools
+-----
+
+### Emacs mode
+
+* Asynchronous Emacs mode.
+
+ One can now use Emacs while a buffer is type-checked. If the buffer
+ is edited while the type-checker runs, then syntax highlighting will
+ not be updated when type-checking is complete.
+
+* Interactive syntax highlighting.
+
+ The syntax highlighting is updated while a buffer is type-checked:
+
+ - At first the buffer is highlighted in a somewhat crude way
+ (without go-to-definition information for overloaded
+ constructors).
+
+ - If the highlighting level is "interactive", then the piece of code
+ that is currently being type-checked is highlighted as such. (The
+ default is "non-interactive".)
+
+ - When a mutual block has been type-checked it is highlighted
+ properly (this highlighting includes warnings for potential
+ non-termination).
+
+ The highlighting level can be controlled via the new configuration
+ variable `agda2-highlight-level`.
+
+* Multiple case-splits can now be performed in one go.
+
+ Consider the following example:
+
+ ```agda
+ _==_ : Bool → Bool → Bool
+ b₁ == b₂ = {!!}
+ ```
+
+ If you split on `b₁ b₂`, then you get the following code:
+
+ ```agda
+ _==_ : Bool → Bool → Bool
+ true == true = {!!}
+ true == false = {!!}
+ false == true = {!!}
+ false == false = {!!}
+ ```
+
+ The order of the variables matters. Consider the following code:
+
+ ```agda
+ lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A
+ lookup xs i = {!!}
+ ```
+
+ If you split on `xs i`, then you get the following code:
+
+ ```agda
+ lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A
+ lookup [] ()
+ lookup (x ∷ xs) zero = {!!}
+ lookup (x ∷ xs) (suc i) = {!!}
+ ```
+
+ However, if you split on `i xs`, then you get the following code
+ instead:
+
+ ```agda
+ lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A
+ lookup (x ∷ xs) zero = ?
+ lookup (x ∷ xs) (suc i) = ?
+ ```
+
+ This code is rejected by Agda 2.3.0, but accepted by 2.3.2 thanks
+ to improved coverage checking (see above).
+
+* The Emacs mode now presents information about which module is
+ currently being type-checked.
+
+* New global menu entry: `Information about the character at point`.
+
+ If this entry is selected, then information about the character at
+ point is displayed, including (in many cases) information about how
+ to type the character.
+
+* Commenting/uncommenting the rest of the buffer.
+
+ One can now comment or uncomment the rest of the buffer by typing
+ `C-c C-x M-;` or by selecting the menu entry `Comment/uncomment` the
+ rest of the buffer".
+
+* The Emacs mode now uses the Agda executable instead of GHCi.
+
+ The `*ghci*` buffer has been renamed to `*agda2*`.
+
+ A new configuration variable has been introduced:
+ `agda2-program-name`, the name of the Agda executable (by default
+ `agda`).
+
+ The variable `agda2-ghci-options` has been replaced by
+ `agda2-program-args`: extra arguments given to the Agda executable
+ (by default `none`).
+
+ If you want to limit Agda's memory consumption you can add some
+ arguments to `agda2-program-args`, for instance `+RTS -M1.5G -RTS`.
+
+* The Emacs mode no longer depends on haskell-mode.
+
+ Users who have customised certain haskell-mode variables (such as
+ `haskell-ghci-program-args`) may want to update their configuration.
+
+### LaTeX-backend
+
+An experimental LaTeX-backend which does precise highlighting a la the
+HTML-backend and code alignment a la lhs2TeX has been added.
+
+Here is a sample input literate Agda file:
+
+ ```latex
+ \documentclass{article}
+
+ \usepackage{agda}
+
+ \begin{document}
+
+ The following module declaration will be hidden in the output.
+
+ \AgdaHide{
+ \begin{code}
+ module M where
+ \end{code}
+ }
+
+ Two or more spaces can be used to make the backend align stuff.
+
+ \begin{code}
+ data ℕ : Set where
+ zero : ℕ
+ suc : ℕ → ℕ
+
+ _+_ : ℕ → ℕ → ℕ
+ zero + n = n
+ suc m + n = suc (m + n)
+ \end{code}
+
+ \end{document}
+ ```
+
+To produce an output PDF issue the following commands:
+
+ ```
+ agda --latex -i . <file>.lagda
+ pdflatex latex/<file>.tex
+ ```
+
+Only the top-most module is processed, like with lhs2tex and unlike
+with the HTML-backend. If you want to process imported modules you
+have to call `agda --latex` manually on each of those modules.
+
+There are still issues related to formatting, see the bug tracker for
+more information:
+
+ https://code.google.com/p/agda/issues/detail?id=697
+
+The default `agda.sty` might therefore change in backwards-incompatible
+ways, as work proceeds in trying to resolve those problems.
+
+Implemented features:
+
+* Two or more spaces can be used to force alignment of things, like
+ with lhs2tex. See example above.
+
+* The highlighting information produced by the type checker is used to
+ generate the output. For example, the data declaration in the
+ example above, produces:
+
+ ```agda
+ \AgdaKeyword{data} \AgdaDatatype{ℕ} \AgdaSymbol{:}
+ \AgdaPrimitiveType{Set} \AgdaKeyword{where}
+ ```
+
+ These LaTeX commands are defined in `agda.sty` (which is imported by
+ `\usepackage{agda}`) and cause the highlighting.
+
+* The LaTeX-backend checks if `agda.sty` is found by the LaTeX
+ environment, if it isn't a default `agda.sty` is copied from Agda's
+ `data-dir` into the working directory (and thus made available to
+ the LaTeX environment).
+
+ If the default `agda.sty` isn't satisfactory (colors, fonts,
+ spacing, etc) then the user can modify it and make put it somewhere
+ where the LaTeX environment can find it. Hopefully most aspects
+ should be modifiable via `agda.sty` rather than having to tweak the
+ implementation.
+
+* `--latex-dir` can be used to change the default output directory.
+
+Release notes for Agda 2 version 2.3.0
+======================================
+
+Language
+--------
+
+* New more liberal syntax for mutually recursive definitions.
+
+ It is no longer necessary to use the `mutual` keyword to define
+ mutually recursive functions or datatypes. Instead, it is enough to
+ declare things before they are used. Instead of
+
+ ```agda
+ mutual
+ f : A
+ f = a[f, g]
+
+ g : B[f]
+ g = b[f, g]
+ ```
+
+ you can now write
+
+ ```agda
+ f : A
+ g : B[f]
+ f = a[f, g]
+ g = b[f, g].
+ ```
+
+ With the new style you have more freedom in choosing the order in
+ which things are type checked (previously type signatures were
+ always checked before definitions). Furthermore you can mix
+ arbitrary declarations, such as modules and postulates, with
+ mutually recursive definitions.
+
+ For data types and records the following new syntax is used to
+ separate the declaration from the definition:
+
+ ```agda
+ -- Declaration.
+ data Vec (A : Set) : Nat → Set -- Note the absence of 'where'.
+
+ -- Definition.
+ data Vec A where
+ [] : Vec A zero
+ _::_ : {n : Nat} → A → Vec A n → Vec A (suc n)
+
+ -- Declaration.
+ record Sigma (A : Set) (B : A → Set) : Set
+
+ -- Definition.
+ record Sigma A B where
+ constructor _,_
+ field fst : A
+ snd : B fst
+ ```
+
+ When making separated declarations/definitions private or abstract
+ you should attach the `private` keyword to the declaration and the
+ `abstract` keyword to the definition. For instance, a private,
+ abstract function can be defined as
+
+ ```agda
+ private
+ f : A
+ abstract
+ f = e
+ ```
+
+ Finally it may be worth noting that the old style of mutually
+ recursive definitions is still supported (it basically desugars into
+ the new style).
+
+* Pattern matching lambdas.
+
+ Anonymous pattern matching functions can be defined using the syntax
+
+ ```
+ \ { p11 .. p1n -> e1 ; ... ; pm1 .. pmn -> em }
+ ```
+
+ (where, as usual, `\` and `->` can be replaced by `λ` and
+ `→`). Internally this is translated into a function definition of
+ the following form:
+
+ ```
+ .extlam p11 .. p1n = e1
+ ...
+ .extlam pm1 .. pmn = em
+ ```
+
+ This means that anonymous pattern matching functions are generative.
+ For instance, `refl` will not be accepted as an inhabitant of the type
+
+ ```agda
+ (λ { true → true ; false → false }) ≡
+ (λ { true → true ; false → false }),
+ ```
+
+ because this is equivalent to `extlam1 ≡ extlam2` for some distinct
+ fresh names `extlam1` and `extlam2`.
+
+ Currently the `where` and `with` constructions are not allowed in
+ (the top-level clauses of) anonymous pattern matching functions.
+
+ Examples:
+
+ ```agda
+ and : Bool → Bool → Bool
+ and = λ { true x → x ; false _ → false }
+
+ xor : Bool → Bool → Bool
+ xor = λ { true true → false
+ ; false false → false
+ ; _ _ → true
+ }
+
+ fst : {A : Set} {B : A → Set} → Σ A B → A
+ fst = λ { (a , b) → a }
+
+ snd : {A : Set} {B : A → Set} (p : Σ A B) → B (fst p)
+ snd = λ { (a , b) → b }
+ ```
+
+* Record update syntax.
+
+ Assume that we have a record type and a corresponding value:
+
+ ```agda
+ record MyRecord : Set where
+ field
+ a b c : ℕ
+
+ old : MyRecord
+ old = record { a = 1; b = 2; c = 3 }
+ ```
+
+ Then we can update (some of) the record value's fields in the
+ following way:
+
+ ```agda
+ new : MyRecord
+ new = record old { a = 0; c = 5 }
+ ```
+
+ Here new normalises to `record { a = 0; b = 2; c = 5 }`. Any
+ expression yielding a value of type `MyRecord` can be used instead of
+ old.
+
+ Record updating is not allowed to change types: the resulting value
+ must have the same type as the original one, including the record
+ parameters. Thus, the type of a record update can be inferred if the
+ type of the original record can be inferred.
+
+ The record update syntax is expanded before type checking. When the
+ expression
+
+ ```agda
+ record old { upd-fields }
+ ```
+
+ is checked against a record type `R`, it is expanded to
+
+ ```agda
+ let r = old in record { new-fields },
+ ```
+
+ where old is required to have type `R` and new-fields is defined as
+ follows: for each field `x` in `R`,
+
+ - if `x = e` is contained in `upd-fields` then `x = e` is included in
+ `new-fields`, and otherwise
+
+ - if `x` is an explicit field then `x = R.x r` is included in
+ `new-fields`, and
+
+ - if `x` is an implicit or instance field, then it is omitted from
+ `new-fields`.
+
+ (Instance arguments are explained below.) The reason for treating
+ implicit and instance fields specially is to allow code like the
+ following:
+
+ ```agda
+ record R : Set where
+ field
+ {length} : ℕ
+ vec : Vec ℕ length
+ -- More fields…
+
+ xs : R
+ xs = record { vec = 0 ∷ 1 ∷ 2 ∷ [] }
+
+ ys = record xs { vec = 0 ∷ [] }
+ ```
+
+ Without the special treatment the last expression would need to
+ include a new binding for length (for instance `length = _`).
+
+* Record patterns which do not contain data type patterns, but which
+ do contain dot patterns, are no longer rejected.
+
+* When the `--without-K` flag is used literals are now treated as
+ constructors.
+
+* Under-applied functions can now reduce.
+
+ Consider the following definition:
+
+ ```agda
+ id : {A : Set} → A → A
+ id x = x
+ ```
+
+ Previously the expression `id` would not reduce. This has been
+ changed so that it now reduces to `λ x → x`. Usually this makes
+ little difference, but it can be important in conjunction with
+ `with`. See Issue [#365](https://github.com/agda/agda/issues/365)
+ for an example.
+
+* Unused AgdaLight legacy syntax `(x y : A; z v : B)` for telescopes
+ has been removed.
+
+### Universe polymorphism
+
+* Universe polymorphism is now enabled by default. Use
+ `--no-universe-polymorphism` to disable it.
+
+* Universe levels are no longer defined as a data type.
+
+ The basic level combinators can be introduced in the following way:
+
+ ```agda
+ postulate
+ Level : Set
+ zero : Level
+ suc : Level → Level
+ max : Level → Level → Level
+
+ {-# BUILTIN LEVEL Level #-}
+ {-# BUILTIN LEVELZERO zero #-}
+ {-# BUILTIN LEVELSUC suc #-}
+ {-# BUILTIN LEVELMAX max #-}
+ ```
+
+* The BUILTIN equality is now required to be universe-polymorphic.
+
+* `trustMe` is now universe-polymorphic.
+
+### Meta-variables and unification
+
+* Unsolved meta-variables are now frozen after every mutual block.
+ This means that they cannot be instantiated by subsequent code. For
+ instance,
+
+ ```agda
+ one : Nat
+ one = _
+
+ bla : one ≡ suc zero
+ bla = refl
+ ```
+
+ leads to an error now, whereas previously it lead to the
+ instantiation of `_` with `suc zero`. If you want to make use of the
+ old behaviour, put the two definitions in a mutual block.
+
+ All meta-variables are unfrozen during interactive editing, so that
+ the user can fill holes interactively. Note that type-checking of
+ interactively given terms is not perfect: Agda sometimes refuses to
+ load a file, even though no complaints were raised during the
+ interactive construction of the file. This is because certain checks
+ (for instance, positivity) are only invoked when a file is loaded.
+
+* Record types can now be inferred.
+
+ If there is a unique known record type with fields matching the
+ fields in a record expression, then the type of the expression will
+ be inferred to be the record type applied to unknown parameters.
+
+ If there is no known record type with the given fields the type
+ checker will give an error instead of producing lots of unsolved
+ meta-variables.
+
+ Note that "known record type" refers to any record type in any
+ imported module, not just types which are in scope.
+
+* The occurrence checker distinguishes rigid and strongly rigid
+ occurrences [Reed, LFMTP 2009; Abel & Pientka, TLCA 2011].
+
+ The completeness checker now accepts the following code:
+
+ ```agda
+ h : (n : Nat) → n ≡ suc n → Nat
+ h n ()
+ ```
+
+ Internally this generates a constraint `_n = suc _n` where the
+ meta-variable `_n` occurs strongly rigidly, i.e. on a constructor
+ path from the root, in its own defining term tree. This is never
+ solvable.
+
+ Weakly rigid recursive occurrences may have a solution [Jason Reed's
+ PhD thesis, page 106]:
+
+ ```agda
+ test : (k : Nat) →
+ let X : (Nat → Nat) → Nat
+ X = _
+ in
+ (f : Nat → Nat) → X f ≡ suc (f (X (λ x → k)))
+ test k f = refl
+ ```
+
+ The constraint `_X k f = suc (f (_X k (λ x → k)))` has the solution
+ `_X k f = suc (f (suc k))`, despite the recursive occurrence of
+ `_X`. Here `_X` is not strongly rigid, because it occurs under the
+ bound variable `f`. Previously Agda rejected this code; now it instead
+ complains about an unsolved meta-variable.
+
+* Equation constraints involving the same meta-variable in the head
+ now trigger pruning [Pientka, PhD, Sec. 3.1.2; Abel & Pientka, TLCA
+ 2011]. Example:
+
+ ```agda
+ same : let X : A → A → A → A × A
+ X = _
+ in {x y z : A} → X x y y ≡ (x , y)
+ × X x x y ≡ X x y y
+ same = refl , refl
+ ```
+
+ The second equation implies that `X` cannot depend on its second
+ argument. After pruning the first equation is linear and can be
+ solved.
+
+* Instance arguments.
+
+ A new type of hidden function arguments has been added: instance
+ arguments. This new feature is based on influences from Scala's
+ implicits and Agda's existing implicit arguments.
+
+ Plain implicit arguments are marked by single braces: `{…}`. Instance
+ arguments are instead marked by double braces: `{{…}}`. Example:
+
+ ```agda
+ postulate
+ A : Set
+ B : A → Set
+ a : A
+ f : {{a : A}} → B a
+ ```
+
+ Instead of the double braces you can use the symbols `⦃` and `⦄`,
+ but these symbols must in many cases be surrounded by
+ whitespace. (If you are using Emacs and the Agda input method, then
+ you can conjure up the symbols by typing `\{{` and `\}}`,
+ respectively.)
+
+ Instance arguments behave as ordinary implicit arguments, except for
+ one important aspect: resolution of arguments which are not provided
+ explicitly. For instance, consider the following code:
+
+ ```agda
+ test = f
+ ```
+
+ Here Agda will notice that `f`'s instance argument was not provided
+ explicitly, and try to infer it. All definitions in scope at `f`'s
+ call site, as well as all variables in the context, are considered.
+ If exactly one of these names has the required type `A`, then the
+ instance argument will be instantiated to this name.
+
+ This feature can be used as an alternative to Haskell type classes.
+ If we define
+
+ ```agda
+ record Eq (A : Set) : Set where
+ field equal : A → A → Bool,
+ ```
+
+ then we can define the following projection:
+
+ ```agda
+ equal : {A : Set} {{eq : Eq A}} → A → A → Bool
+ equal {{eq}} = Eq.equal eq
+ ```
+
+ Now consider the following expression:
+
+ ```agda
+ equal false false ∨ equal 3 4
+ ```
+
+ If the following `Eq` "instances" for `Bool` and `ℕ` are in scope, and no
+ others, then the expression is accepted:
+
+ ```agda
+ eq-Bool : Eq Bool
+ eq-Bool = record { equal = … }
+
+ eq-ℕ : Eq ℕ
+ eq-ℕ = record { equal = … }
+ ```
+
+ A shorthand notation is provided to avoid the need to define
+ projection functions manually:
+
+ ```agda
+ module Eq-with-implicits = Eq {{...}}
+ ```
+
+ This notation creates a variant of `Eq`'s record module, where the
+ main `Eq` argument is an instance argument instead of an explicit one.
+ It is equivalent to the following definition:
+
+ ```agda
+ module Eq-with-implicits {A : Set} {{eq : Eq A}} = Eq eq
+ ```
+
+ Note that the short-hand notation allows you to avoid naming the
+ "-with-implicits" module:
+
+ ```agda
+ open Eq {{...}}
+ ```
+
+ Instance argument resolution is not recursive. As an example,
+ consider the following "parametrised instance":
+
+ ```agda
+ eq-List : {A : Set} → Eq A → Eq (List A)
+ eq-List {A} eq = record { equal = eq-List-A }
+ where
+ eq-List-A : List A → List A → Bool
+ eq-List-A [] [] = true
+ eq-List-A (a ∷ as) (b ∷ bs) = equal a b ∧ eq-List-A as bs
+ eq-List-A _ _ = false
+ ```
+
+ Assume that the only `Eq` instances in scope are `eq-List` and
+ `eq-ℕ`. Then the following code does not type-check:
+
+ ```agda
+ test = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])
+ ```
+
+ However, we can make the code work by constructing a suitable
+ instance manually:
+
+ ```agda
+ test′ = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])
+ where eq-List-ℕ = eq-List eq-ℕ
+ ```
+
+ By restricting the "instance search" to be non-recursive we avoid
+ introducing a new, compile-time-only evaluation model to Agda.
+
+ For more information about instance arguments, see Devriese &
+ Piessens [ICFP 2011]. Some examples are also available in the
+ examples/instance-arguments subdirectory of the Agda distribution.
+
+### Irrelevance
+
+* Dependent irrelevant function types.
+
+ Some examples illustrating the syntax of dependent irrelevant
+ function types:
+
+ ```
+ .(x y : A) → B .{x y z : A} → B
+ ∀ x .y → B ∀ x .{y} {z} .v → B
+ ```
+
+ The declaration
+
+ ```
+ f : .(x : A) → B[x]
+ f x = t[x]
+ ```
+
+ requires that `x` is irrelevant both in `t[x]` and in `B[x]`. This
+ is possible if, for instance, `B[x] = B′ x`, with `B′ : .A → Set`.
+
+ Dependent irrelevance allows us to define the eliminator for the
+ `Squash` type:
+
+ ```agda
+ record Squash (A : Set) : Set where
+ constructor squash
+ field
+ .proof : A
+
+ elim-Squash : {A : Set} (P : Squash A → Set)
+ (ih : .(a : A) → P (squash a)) →
+ (a⁻ : Squash A) → P a⁻
+ elim-Squash P ih (squash a) = ih a
+ ```
+
+ Note that this would not type-check with
+
+ ```agda
+ (ih : (a : A) -> P (squash a)).
+ ```
+
+* Records with only irrelevant fields.
+
+ The following now works:
+
+ ```agda
+ record IsEquivalence {A : Set} (_≈_ : A → A → Set) : Set where
+ field
+ .refl : Reflexive _≈_
+ .sym : Symmetric _≈_
+ .trans : Transitive _≈_
+
+ record Setoid : Set₁ where
+ infix 4 _≈_
+ field
+ Carrier : Set
+ _≈_ : Carrier → Carrier → Set
+ .isEquivalence : IsEquivalence _≈_
+
+ open IsEquivalence isEquivalence public
+ ```
+
+ Previously Agda complained about the application
+ `IsEquivalence isEquivalence`, because `isEquivalence` is irrelevant
+ and the `IsEquivalence` module expected a relevant argument. Now,
+ when record modules are generated for records consisting solely of
+ irrelevant arguments, the record parameter is made irrelevant:
+
+ ```agda
+ module IsEquivalence {A : Set} {_≈_ : A → A → Set}
+ .(r : IsEquivalence {A = A} _≈_) where
+ …
+ ```
+
+* Irrelevant things are no longer erased internally. This means that
+ they are printed as ordinary terms, not as `_` as before.
+
+* The new flag `--experimental-irrelevance` enables irrelevant
+ universe levels and matching on irrelevant data when only one
+ constructor is available. These features are very experimental and
+ likely to change or disappear.
+
+### Reflection
+
+* The reflection API has been extended to mirror features like
+ irrelevance, instance arguments and universe polymorphism, and to
+ give (limited) access to definitions. For completeness all the
+ builtins and primitives are listed below:
+
+ ```agda
+ -- Names.
+
+ postulate Name : Set
+
+ {-# BUILTIN QNAME Name #-}
+
+ primitive
+ -- Equality of names.
+ primQNameEquality : Name → Name → Bool
+
+ -- Is the argument visible (explicit), hidden (implicit), or an
+ -- instance argument?
+
+ data Visibility : Set where
+ visible hidden instance : Visibility
+
+ {-# BUILTIN HIDING Visibility #-}
+ {-# BUILTIN VISIBLE visible #-}
+ {-# BUILTIN HIDDEN hidden #-}
+ {-# BUILTIN INSTANCE instance #-}
+
+ -- Arguments can be relevant or irrelevant.
+
+ data Relevance : Set where
+ relevant irrelevant : Relevance
+
+ {-# BUILTIN RELEVANCE Relevance #-}
+ {-# BUILTIN RELEVANT relevant #-}
+ {-# BUILTIN IRRELEVANT irrelevant #-}
+
+ -- Arguments.
+
+ data Arg A : Set where
+ arg : (v : Visibility) (r : Relevance) (x : A) → Arg A
+
+ {-# BUILTIN ARG Arg #-}
+ {-# BUILTIN ARGARG arg #-}
+
+ -- Terms.
+
+ mutual
+ data Term : Set where
+ -- Variable applied to arguments.
+ var : (x : ℕ) (args : List (Arg Term)) → Term
+ -- Constructor applied to arguments.
+ con : (c : Name) (args : List (Arg Term)) → Term
+ -- Identifier applied to arguments.
+ def : (f : Name) (args : List (Arg Term)) → Term
+ -- Different kinds of λ-abstraction.
+ lam : (v : Visibility) (t : Term) → Term
+ -- Pi-type.
+ pi : (t₁ : Arg Type) (t₂ : Type) → Term
+ -- A sort.
+ sort : Sort → Term
+ -- Anything else.
+ unknown : Term
+
+ data Type : Set where
+ el : (s : Sort) (t : Term) → Type
+
+ data Sort : Set where
+ -- A Set of a given (possibly neutral) level.
+ set : (t : Term) → Sort
+ -- A Set of a given concrete level.
+ lit : (n : ℕ) → Sort
+ -- Anything else.
+ unknown : Sort
+
+ {-# BUILTIN AGDASORT Sort #-}
+ {-# BUILTIN AGDATYPE Type #-}
+ {-# BUILTIN AGDATERM Term #-}
+ {-# BUILTIN AGDATERMVAR var #-}
+ {-# BUILTIN AGDATERMCON con #-}
+ {-# BUILTIN AGDATERMDEF def #-}
+ {-# BUILTIN AGDATERMLAM lam #-}
+ {-# BUILTIN AGDATERMPI pi #-}
+ {-# BUILTIN AGDATERMSORT sort #-}
+ {-# BUILTIN AGDATERMUNSUPPORTED unknown #-}
+ {-# BUILTIN AGDATYPEEL el #-}
+ {-# BUILTIN AGDASORTSET set #-}
+ {-# BUILTIN AGDASORTLIT lit #-}
+ {-# BUILTIN AGDASORTUNSUPPORTED unknown #-}
+
+ postulate
+ -- Function definition.
+ Function : Set
+ -- Data type definition.
+ Data-type : Set
+ -- Record type definition.
+ Record : Set
+
+ {-# BUILTIN AGDAFUNDEF Function #-}
+ {-# BUILTIN AGDADATADEF Data-type #-}
+ {-# BUILTIN AGDARECORDDEF Record #-}
+
+ -- Definitions.
+
+ data Definition : Set where
+ function : Function → Definition
+ data-type : Data-type → Definition
+ record′ : Record → Definition
+ constructor′ : Definition
+ axiom : Definition
+ primitive′ : Definition
+
+ {-# BUILTIN AGDADEFINITION Definition #-}
+ {-# BUILTIN AGDADEFINITIONFUNDEF function #-}
+ {-# BUILTIN AGDADEFINITIONDATADEF data-type #-}
+ {-# BUILTIN AGDADEFINITIONRECORDDEF record′ #-}
+ {-# BUILTIN AGDADEFINITIONDATACONSTRUCTOR constructor′ #-}
+ {-# BUILTIN AGDADEFINITIONPOSTULATE axiom #-}
+ {-# BUILTIN AGDADEFINITIONPRIMITIVE primitive′ #-}
+
+ primitive
+ -- The type of the thing with the given name.
+ primQNameType : Name → Type
+ -- The definition of the thing with the given name.
+ primQNameDefinition : Name → Definition
+ -- The constructors of the given data type.
+ primDataConstructors : Data-type → List Name
+ ```
+
+ As an example the expression
+
+ ```agda
+ primQNameType (quote zero)
+ ```
+
+ is definitionally equal to
+
+ ```agda
+ el (lit 0) (def (quote ℕ) [])
+ ```
+
+ (if `zero` is a constructor of the data type `ℕ`).
+
+* New keyword: `unquote`.
+
+ The construction `unquote t` converts a representation of an Agda term
+ to actual Agda code in the following way:
+
+ 1. The argument `t` must have type `Term` (see the reflection API above).
+
+ 2. The argument is normalised.
+
+ 3. The entire construction is replaced by the normal form, which is
+ treated as syntax written by the user and type-checked in the
+ usual way.
+
+ Examples:
+
+ ```agda
+ test : unquote (def (quote ℕ) []) ≡ ℕ
+ test = refl
+
+ id : (A : Set) → A → A
+ id = unquote (lam visible (lam visible (var 0 [])))
+
+ id-ok : id ≡ (λ A (x : A) → x)
+ id-ok = refl
+ ```
+
+* New keyword: `quoteTerm`.
+
+ The construction `quoteTerm t` is similar to `quote n`, but whereas
+ `quote` is restricted to names `n`, `quoteTerm` accepts terms
+ `t`. The construction is handled in the following way:
+
+ 1. The type of `t` is inferred. The term `t` must be type-correct.
+
+ 2. The term `t` is normalised.
+
+ 3. The construction is replaced by the Term representation (see the
+ reflection API above) of the normal form. Any unsolved metavariables
+ in the term are represented by the `unknown` term constructor.
+
+ Examples:
+
+ ```agda
+ test₁ : quoteTerm (λ {A : Set} (x : A) → x) ≡
+ lam hidden (lam visible (var 0 []))
+ test₁ = refl
+
+ -- Local variables are represented as de Bruijn indices.
+ test₂ : (λ {A : Set} (x : A) → quoteTerm x) ≡ (λ x → var 0 [])
+ test₂ = refl
+
+ -- Terms are normalised before being quoted.
+ test₃ : quoteTerm (0 + 0) ≡ con (quote zero) []
+ test₃ = refl
+ ```
+
+Compiler backends
+-----------------
+
+### MAlonzo
+
+* The MAlonzo backend's FFI now handles universe polymorphism in a
+ better way.
+
+ The translation of Agda types and kinds into Haskell now supports
+ universe-polymorphic postulates. The core changes are that the
+ translation of function types has been changed from
+
+ ```
+ T[[ Pi (x : A) B ]] =
+ if A has a Haskell kind then
+ forall x. () -> T[[ B ]]
+ else if x in fv B then
+ undef
+ else
+ T[[ A ]] -> T[[ B ]]
+ ```
+
+ into
+
+ ```
+ T[[ Pi (x : A) B ]] =
+ if x in fv B then
+ forall x. T[[ A ]] -> T[[ B ]] -- Note: T[[A]] not Unit.
+ else
+ T[[ A ]] -> T[[ B ]],
+ ```
+
+ and that the translation of constants (postulates, constructors and
+ literals) has been changed from
+
+ ```
+ T[[ k As ]] =
+ if COMPILED_TYPE k T then
+ T T[[ As ]]
+ else
+ undef
+ ```
+
+ into
+
+ ```
+ T[[ k As ]] =
+ if COMPILED_TYPE k T then
+ T T[[ As ]]
+ else if COMPILED k E then
+ ()
+ else
+ undef.
+ ```
+
+ For instance, assuming a Haskell definition
+
+ ```haskell
+ type AgdaIO a b = IO b,
+ ```
+
+ we can set up universe-polymorphic `IO` in the following way:
+
+ ```agda
+ postulate
+ IO : ∀ {ℓ} → Set ℓ → Set ℓ
+ return : ∀ {a} {A : Set a} → A → IO A
+ _>>=_ : ∀ {a b} {A : Set a} {B : Set b} →
+ IO A → (A → IO B) → IO B
+
+ {-# COMPILED_TYPE IO AgdaIO #-}
+ {-# COMPILED return (\_ _ -> return) #-}
+ {-# COMPILED _>>=_ (\_ _ _ _ -> (>>=)) #-}
+ ```
+
+ This is accepted because (assuming that the universe level type is
+ translated to the Haskell unit type `()`)
+
+ ```haskell
+ (\_ _ -> return)
+ : forall a. () -> forall b. () -> b -> AgdaIO a b
+ = T [[ ∀ {a} {A : Set a} → A → IO A ]]
+ ```
+
+ and
+
+ ```haskell
+ (\_ _ _ _ -> (>>=))
+ : forall a. () -> forall b. () ->
+ forall c. () -> forall d. () ->
+ AgdaIO a c -> (c -> AgdaIO b d) -> AgdaIO b d
+ = T [[ ∀ {a b} {A : Set a} {B : Set b} →
+ IO A → (A → IO B) → IO B ]].
+ ```
+
+### Epic
+
+* New Epic backend pragma: `STATIC`.
+
+ In the Epic backend, functions marked with the `STATIC` pragma will be
+ normalised before compilation. Example usage:
+
+ ```
+ {-# STATIC power #-}
+
+ power : ℕ → ℕ → ℕ
+ power 0 x = 1
+ power 1 x = x
+ power (suc n) x = power n x * x
+ ```
+
+ Occurrences of `power 4 x` will be replaced by `((x * x) * x) * x`.
+
+* Some new optimisations have been implemented in the Epic backend:
+
+ - Removal of unused arguments.
+
+ A worker/wrapper transformation is performed so that unused
+ arguments can be removed by Epic's inliner. For instance, the map
+ function is transformed in the following way:
+
+ ```agda
+ map_wrap : (A B : Set) → (A → B) → List A → List B
+ map_wrap A B f xs = map_work f xs
+
+ map_work f [] = []
+ map_work f (x ∷ xs) = f x ∷ map_work f xs
+ ```
+
+ If `map_wrap` is inlined (which it will be in any saturated call),
+ then `A` and `B` disappear in the generated code.
+
+ Unused arguments are found using abstract interpretation. The bodies
+ of all functions in a module are inspected to decide which variables
+ are used. The behaviour of postulates is approximated based on their
+ types. Consider `return`, for instance:
+
+ ```agda
+ postulate return : {A : Set} → A → IO A
+ ```
+
+ The first argument of `return` can be removed, because it is of type
+ Set and thus cannot affect the outcome of a program at runtime.
+
+ - Injection detection.
+
+ At runtime many functions may turn out to be inefficient variants of
+ the identity function. This is especially true after forcing.
+ Injection detection replaces some of these functions with more
+ efficient versions. Example:
+
+ ```agda
+ inject : {n : ℕ} → Fin n → Fin (1 + n)
+ inject {suc n} zero = zero
+ inject {suc n} (suc i) = suc (inject {n} i)
+ ```
+
+ Forcing removes the `Fin` constructors' `ℕ` arguments, so this
+ function is an inefficient identity function that can be replaced by
+ the following one:
+
+ ```agda
+ inject {_} x = x
+ ```
+
+ To actually find this function, we make the induction hypothesis
+ that inject is an identity function in its second argument and look
+ at the branches of the function to decide if this holds.
+
+ Injection detection also works over data type barriers. Example:
+
+ ```agda
+ forget : {A : Set} {n : ℕ} → Vec A n → List A
+ forget [] = []
+ forget (x ∷ xs) = x ∷ forget xs
+ ```
+
+ Given that the constructor tags (in the compiled Epic code) for
+ `Vec.[]` and `List.[]` are the same, and that the tags for `Vec._∷_`
+ and `List._∷_` are also the same, this is also an identity
+ function. We can hence replace the definition with the following
+ one:
+
+ ```agda
+ forget {_} xs = xs
+ ```
+
+ To get this to apply as often as possible, constructor tags are
+ chosen *after* injection detection has been run, in a way to make as
+ many functions as possible injections.
+
+ Constructor tags are chosen once per source file, so it may be
+ advantageous to define conversion functions like forget in the same
+ module as one of the data types. For instance, if `Vec.agda` imports
+ `List.agda`, then the forget function should be put in `Vec.agda` to
+ ensure that vectors and lists get the same tags (unless some other
+ injection function, which puts different constraints on the tags, is
+ prioritised).
+
+ - Smashing.
+
+ This optimisation finds types whose values are inferable at runtime:
+
+ * A data type with only one constructor where all fields are
+ inferable is itself inferable.
+
+ * `Set ℓ` is inferable (as it has no runtime representation).
+
+ A function returning an inferable data type can be smashed, which
+ means that it is replaced by a function which simply returns the
+ inferred value.
+
+ An important example of an inferable type is the usual propositional
+ equality type (`_≡_`). Any function returning a propositional
+ equality can simply return the reflexivity constructor directly
+ without computing anything.
+
+ This optimisation makes more arguments unused. It also makes the
+ Epic code size smaller, which in turn speeds up compilation.
+
+### JavaScript
+
+* ECMAScript compiler backend.
+
+ A new compiler backend is being implemented, targetting ECMAScript
+ (also known as JavaScript), with the goal of allowing Agda programs
+ to be run in browsers or other ECMAScript environments.
+
+ The backend is still at an experimental stage: the core language is
+ implemented, but many features are still missing.
+
+ The ECMAScript compiler can be invoked from the command line using
+ the flag `--js`:
+
+ ```
+ agda --js --compile-dir=<DIR> <FILE>.agda
+ ```
+
+ Each source `<FILE>.agda` is compiled into an ECMAScript target
+ `<DIR>/jAgda.<TOP-LEVEL MODULE NAME>.js`. The compiler can also be
+ invoked using the Emacs mode (the variable `agda2-backend` controls
+ which backend is used).
+
+ Note that ECMAScript is a strict rather than lazy language. Since
+ Agda programs are total, this should not impact program semantics,
+ but it may impact their space or time usage.
+
+ ECMAScript does not support algebraic datatypes or pattern-matching.
+ These features are translated to a use of the visitor pattern. For
+ instance, the standard library's `List` data type and `null`
+ function are translated into the following code:
+
+ ```javascript
+ exports["List"] = {};
+ exports["List"]["[]"] = function (x0) {
+ return x0["[]"]();
+ };
+ exports["List"]["_∷_"] = function (x0) {
+ return function (x1) {
+ return function (x2) {
+ return x2["_∷_"](x0, x1);
+ };
+ };
+ };
+
+ exports["null"] = function (x0) {
+ return function (x1) {
+ return function (x2) {
+ return x2({
+ "[]": function () {
+ return jAgda_Data_Bool["Bool"]["true"];
+ },
+ "_∷_": function (x3, x4) {
+ return jAgda_Data_Bool["Bool"]["false"];
+ }
+ });
+ };
+ };
+ };
+ ```
+
+ Agda records are translated to ECMAScript objects, preserving field
+ names.
+
+ Top-level Agda modules are translated to ECMAScript modules,
+ following the `common.js` module specification. A top-level Agda
+ module `Foo.Bar` is translated to an ECMAScript module
+ `jAgda.Foo.Bar`.
+
+ The ECMAScript compiler does not compile to Haskell, so the pragmas
+ related to the Haskell FFI (`IMPORT`, `COMPILED_DATA` and
+ `COMPILED`) are not used by the ECMAScript backend. Instead, there
+ is a `COMPILED_JS` pragma which may be applied to any
+ declaration. For postulates, primitives, functions and values, it
+ gives the ECMAScript code to be emitted by the compiler. For data
+ types, it gives a function which is applied to a value of that type,
+ and a visitor object. For instance, a binding of natural numbers to
+ ECMAScript integers (ignoring overflow errors) is:
+
+ ```agda
+ data ℕ : Set where
+ zero : ℕ
+ suc : ℕ → ℕ
+
+ {-# COMPILED_JS ℕ function (x,v) {
+ if (x < 1) { return v.zero(); } else { return v.suc(x-1); }
+ } #-}
+ {-# COMPILED_JS zero 0 #-}
+ {-# COMPILED_JS suc function (x) { return x+1; } #-}
+
+ _+_ : ℕ → ℕ → ℕ
+ zero + n = n
+ suc m + n = suc (m + n)
+
+ {-# COMPILED_JS _+_ function (x) { return function (y) {
+ return x+y; };
+ } #-}
+ ```
+
+ To allow FFI code to be optimised, the ECMAScript in a `COMPILED_JS`
+ declaration is parsed, using a simple parser that recognises a pure
+ functional subset of ECMAScript, consisting of functions, function
+ applications, return, if-statements, if-expressions,
+ side-effect-free binary operators (no precedence, left associative),
+ side-effect-free prefix operators, objects (where all member names
+ are quoted), field accesses, and string and integer literals.
+ Modules may be imported using the require (`<module-id>`) syntax: any
+ impure code, or code outside the supported fragment, can be placed
+ in a module and imported.
+
+Tools
+-----
+
+* New flag `--safe`, which can be used to type-check untrusted code.
+
+ This flag disables postulates, `primTrustMe`, and "unsafe" OPTION
+ pragmas, some of which are known to make Agda inconsistent.
+
+ Rejected pragmas:
+
+ ```
+ --allow-unsolved-metas
+ --experimental-irrelevance
+ --guardedness-preserving-type-construtors
+ --injective-type-constructors
+ --no-coverage-check
+ --no-positivity-check
+ --no-termination-check
+ --sized-types
+ --type-in-type
+ ```
+
+ Note that, at the moment, it is not possible to define the universe
+ level or coinduction primitives when `--safe` is used (because they
+ must be introduced as postulates). This can be worked around by
+ type-checking trusted files in a first pass, without using `--safe`,
+ and then using `--saf`e in a second pass. Modules which have already
+ been type-checked are not re-type-checked just because `--safe` is
+ used.
+
+* Dependency graphs.
+
+ The new flag `--dependency-graph=FILE` can be used to generate a DOT
+ file containing a module dependency graph. The generated file (FILE)
+ can be rendered using a tool like dot.
+
+* The `--no-unreachable-check` flag has been removed.
+
+* Projection functions are highlighted as functions instead of as
+ fields. Field names (in record definitions and record values) are
+ still highlighted as fields.
+
+* Support for jumping to positions mentioned in the information
+ buffer has been added.
+
+* The `make install` command no longer installs Agda globally (by
+ default).
+
+Release notes for Agda 2 version 2.2.10
+=======================================
+
+Language
+--------
+
+* New flag: `--without-K`.
+
+ This flag makes pattern matching more restricted. If the flag is
+ activated, then Agda only accepts certain case-splits. If the type
+ of the variable to be split is `D pars ixs`, where `D` is a data (or
+ record) type, pars stands for the parameters, and `ixs` the indices,
+ then the following requirements must be satisfied:
+
+ - The indices `ixs` must be applications of constructors to distinct
+ variables.
+
+ - These variables must not be free in pars.
+
+ The intended purpose of `--without-K` is to enable experiments with
+ a propositional equality without the K rule. Let us define
+ propositional equality as follows:
+
+ ```agda
+ data _≡_ {A : Set} : A → A → Set where
+ refl : ∀ x → x ≡ x
+ ```
+
+ Then the obvious implementation of the J rule is accepted:
+
+ ```agda
+ J : {A : Set} (P : {x y : A} → x ≡ y → Set) →
+ (∀ x → P (refl x)) →
+ ∀ {x y} (x≡y : x ≡ y) → P x≡y
+ J P p (refl x) = p x
+ ```
+
+ The same applies to Christine Paulin-Mohring's version of the J rule:
+
+ ```agda
+ J′ : {A : Set} {x : A} (P : {y : A} → x ≡ y → Set) →
+ P (refl x) →
+ ∀ {y} (x≡y : x ≡ y) → P x≡y
+ J′ P p (refl x) = p
+ ```
+
+ On the other hand, the obvious implementation of the K rule is not
+ accepted:
+
+ ```agda
+ K : {A : Set} (P : {x : A} → x ≡ x → Set) →
+ (∀ x → P (refl x)) →
+ ∀ {x} (x≡x : x ≡ x) → P x≡x
+ K P p (refl x) = p x
+ ```
+
+ However, we have *not* proved that activation of `--without-K`
+ ensures that the K rule cannot be proved in some other way.
+
+* Irrelevant declarations.
+
+ Postulates and functions can be marked as irrelevant by prefixing
+ the name with a dot when the name is declared. Example:
+
+ ```agda
+ postulate
+ .irrelevant : {A : Set} → .A → A
+ ```
+
+ Irrelevant names may only be used in irrelevant positions or in
+ definitions of things which have been declared irrelevant.
+
+ The axiom irrelevant above can be used to define a projection from
+ an irrelevant record field:
+
+ ```agda
+ data Subset (A : Set) (P : A → Set) : Set where
+ _#_ : (a : A) → .(P a) → Subset A P
+
+ elem : ∀ {A P} → Subset A P → A
+ elem (a # p) = a
+
+ .certificate : ∀ {A P} (x : Subset A P) → P (elem x)
+ certificate (a # p) = irrelevant p
+ ```
+
+ The right-hand side of certificate is relevant, so we cannot define
+
+ ```agda
+ certificate (a # p) = p
+ ```
+
+ (because `p` is irrelevant). However, certificate is declared to be
+ irrelevant, so it can use the axiom irrelevant. Furthermore the
+ first argument of the axiom is irrelevant, which means that
+ irrelevant `p` is well-formed.
+
+ As shown above the axiom irrelevant justifies irrelevant
+ projections. Previously no projections were generated for irrelevant
+ record fields, such as the field certificate in the following
+ record type:
+
+ ```agda
+ record Subset (A : Set) (P : A → Set) : Set where
+ constructor _#_
+ field
+ elem : A
+ .certificate : P elem
+ ```
+
+ Now projections are generated automatically for irrelevant fields
+ (unless the flag `--no-irrelevant-projections` is used). Note that
+ irrelevant projections are highly experimental.
+
+* Termination checker recognises projections.
+
+ Projections now preserve sizes, both in patterns and expressions.
+ Example:
+
+ ```agda
+ record Wrap (A : Set) : Set where
+ constructor wrap
+ field
+ unwrap : A
+
+ open Wrap public
+
+ data WNat : Set where
+ zero : WNat
+ suc : Wrap WNat → WNat
+
+ id : WNat → WNat
+ id zero = zero
+ id (suc w) = suc (wrap (id (unwrap w)))
+ ```
+
+ In the structural ordering `unwrap w` ≤ `w`. This means that
+
+ ```agda
+ unwrap w ≤ w < suc w,
+ ```
+
+ and hence the recursive call to id is accepted.
+
+ Projections also preserve guardedness.
+
+Tools
+-----
+
+* Hyperlinks for top-level module names now point to the start of the
+ module rather than to the declaration of the module name. This
+ applies both to the Emacs mode and to the output of `agda --html`.
+
+* Most occurrences of record field names are now highlighted as
+ "fields". Previously many occurrences were highlighted as
+ "functions".
+
+* Emacs mode: It is no longer possible to change the behaviour of the
+ `TAB` key by customising `agda2-indentation`.
+
+* Epic compiler backend.
+
+ A new compiler backend is being implemented. This backend makes use
+ of Edwin Brady's language Epic
+ (http://www.cs.st-andrews.ac.uk/~eb/epic.php) and its compiler. The
+ backend should handle most Agda code, but is still at an
+ experimental stage: more testing is needed, and some things written
+ below may not be entirely true.
+
+ The Epic compiler can be invoked from the command line using the
+ flag `--epic`:
+
+ ```
+ agda --epic --epic-flag=<EPIC-FLAG> --compile-dir=<DIR> <FILE>.agda
+ ```
+
+ The `--epic-flag` flag can be given multiple times; each flag is
+ given verbatim to the Epic compiler (in the given order). The
+ resulting executable is named after the main module and placed in
+ the directory specified by the `--compile-dir` flag (default: the
+ project root). Intermediate files are placed in a subdirectory
+ called `Epic`.
+
+ The backend requires that there is a definition named main. This
+ definition should be a value of type `IO Unit`, but at the moment
+ this is not checked (so it is easy to produce a program which
+ segfaults). Currently the backend represents actions of type `IO A`
+ as functions from `Unit` to `A`, and main is applied to the unit
+ value.
+
+ The Epic compiler compiles via C, not Haskell, so the pragmas
+ related to the Haskell FFI (`IMPORT`, `COMPILED_DATA` and
+ `COMPILED`) are not used by the Epic backend. Instead there is a new
+ pragma `COMPILED_EPIC`. This pragma is used to give Epic code for
+ postulated definitions (Epic code can in turn call C code). The form
+ of the pragma is `{-# COMPILED_EPIC def code #-}`, where `def` is
+ the name of an Agda postulate and `code` is some Epic code which
+ should include the function arguments, return type and function
+ body. As an example the `IO` monad can be defined as follows:
+
+ ```agda
+ postulate
+ IO : Set → Set
+ return : ∀ {A} → A → IO A
+ _>>=_ : ∀ {A B} → IO A → (A → IO B) → IO B
+
+ {-# COMPILED_EPIC return (u : Unit, a : Any) -> Any =
+ ioreturn(a) #-}
+ {-# COMPILED_EPIC
+ _>>=_ (u1 : Unit, u2 : Unit, x : Any, f : Any) -> Any =
+ iobind(x,f) #-}
+ ```
+
+ Here `ioreturn` and `iobind` are Epic functions which are defined in
+ the file `AgdaPrelude.e` which is always included.
+
+ By default the backend will remove so-called forced constructor
+ arguments (and case-splitting on forced variables will be
+ rewritten). This optimisation can be disabled by using the flag
+ `--no-forcing`.
+
+ All data types which look like unary natural numbers after forced
+ constructor arguments have been removed (i.e. types with two
+ constructors, one nullary and one with a single recursive argument)
+ will be represented as "BigInts". This applies to the standard `Fin`
+ type, for instance.
+
+ The backend supports Agda's primitive functions and the BUILTIN
+ pragmas. If the BUILTIN pragmas for unary natural numbers are used,
+ then some operations, like addition and multiplication, will use
+ more efficient "BigInt" operations.
+
+ If you want to make use of the Epic backend you need to install some
+ dependencies, see the README.
+
+* The Emacs mode can compile using either the MAlonzo or the Epic
+ backend. The variable `agda2-backend` controls which backend is
+ used.
+
+Release notes for Agda 2 version 2.2.8
+======================================
+
+Language
+--------
+
+* Record pattern matching.
+
+ It is now possible to pattern match on named record constructors.
+ Example:
+
+ ```agda
+ record Σ (A : Set) (B : A → Set) : Set where
+ constructor _,_
+ field
+ proj₁ : A
+ proj₂ : B proj₁
+
+ map : {A B : Set} {P : A → Set} {Q : B → Set}
+ (f : A → B) → (∀ {x} → P x → Q (f x)) →
+ Σ A P → Σ B Q
+ map f g (x , y) = (f x , g y)
+ ```
+
+ The clause above is internally translated into the following one:
+
+ ```agda
+ map f g p = (f (Σ.proj₁ p) , g (Σ.proj₂ p))
+ ```
+
+ Record patterns containing data type patterns are not translated.
+ Example:
+
+ ```agda
+ add : ℕ × ℕ → ℕ
+ add (zero , n) = n
+ add (suc m , n) = suc (add (m , n))
+ ```
+
+ Record patterns which do not contain data type patterns, but which
+ do contain dot patterns, are currently rejected. Example:
+
+ ```agda
+ Foo : {A : Set} (p₁ p₂ : A × A) → proj₁ p₁ ≡ proj₁ p₂ → Set₁
+ Foo (x , y) (.x , y′) refl = Set
+ ```
+
+* Proof irrelevant function types.
+
+ Agda now supports irrelevant non-dependent function types:
+
+ ```agda
+ f : .A → B
+ ```
+
+ This type implies that `f` does not depend computationally on its
+ argument. One intended use case is data structures with embedded
+ proofs, like sorted lists:
+
+ ```agda
+ postulate
+ _≤_ : ℕ → ℕ → Set
+ p₁ : 0 ≤ 1
+ p₂ : 0 ≤ 1
+
+ data SList (bound : ℕ) : Set where
+ [] : SList bound
+ scons : (head : ℕ) →
+ .(head ≤ bound) →
+ (tail : SList head) →
+ SList bound
+ ```
+
+ The effect of the irrelevant type in the signature of `scons` is
+ that `scons`'s second argument is never inspected after Agda has
+ ensured that it has the right type. It is even thrown away, leading
+ to smaller term sizes and hopefully some gain in efficiency. The
+ type-checker ignores irrelevant arguments when checking equality, so
+ two lists can be equal even if they contain different proofs:
+
+ ```agda
+ l₁ : SList 1
+ l₁ = scons 0 p₁ []
+
+ l₂ : SList 1
+ l₂ = scons 0 p₂ []
+
+ l₁≡l₂ : l₁ ≡ l₂
+ l₁≡l₂ = refl
+ ```
+
+ Irrelevant arguments can only be used in irrelevant contexts.
+ Consider the following subset type:
+
+ ```agda
+ data Subset (A : Set) (P : A → Set) : Set where
+ _#_ : (elem : A) → .(P elem) → Subset A P
+ ```
+
+ The following two uses are fine:
+
+ ```agda
+ elimSubset : ∀ {A C : Set} {P} →
+ Subset A P → ((a : A) → .(P a) → C) → C
+ elimSubset (a # p) k = k a p
+
+ elem : {A : Set} {P : A → Set} → Subset A P → A
+ elem (x # p) = x
+ ```
+
+ However, if we try to project out the proof component, then Agda
+ complains that `variable p is declared irrelevant, so it cannot be
+ used here`:
+
+ ```agda
+ prjProof : ∀ {A P} (x : Subset A P) → P (elem x)
+ prjProof (a # p) = p
+ ```
+
+ Matching against irrelevant arguments is also forbidden, except in
+ the case of irrefutable matches (record constructor patterns which
+ have been translated away). For instance, the match against the
+ pattern `(p , q)` here is accepted:
+
+ ```agda
+ elim₂ : ∀ {A C : Set} {P Q : A → Set} →
+ Subset A (λ x → Σ (P x) (λ _ → Q x)) →
+ ((a : A) → .(P a) → .(Q a) → C) → C
+ elim₂ (a # (p , q)) k = k a p q
+ ```
+
+ Absurd matches `()` are also allowed.
+
+ Note that record fields can also be irrelevant. Example:
+
+ ```agda
+ record Subset (A : Set) (P : A → Set) : Set where
+ constructor _#_
+ field
+ elem : A
+ .proof : P elem
+ ```
+
+ Irrelevant fields are never in scope, neither inside nor outside the
+ record. This means that no record field can depend on an irrelevant
+ field, and furthermore projections are not defined for such fields.
+ Irrelevant fields can only be accessed using pattern matching, as in
+ `elimSubset` above.
+
+ Irrelevant function types were added very recently, and have not
+ been subjected to much experimentation yet, so do not be surprised
+ if something is changed before the next release. For instance,
+ dependent irrelevant function spaces (`.(x : A) → B`) might be added
+ in the future.
+
+* Mixfix binders.
+
+ It is now possible to declare user-defined syntax that binds
+ identifiers. Example:
+
+ ```agda
+ postulate
+ State : Set → Set → Set
+ put : ∀ {S} → S → State S ⊤
+ get : ∀ {S} → State S S
+ return : ∀ {A S} → A → State S A
+ bind : ∀ {A B S} → State S B → (B → State S A) → State S A
+
+ syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂
+
+ increment : State ℕ ⊤
+ increment = x ← get ,
+ put (1 + x)
+ ```
+
+ The syntax declaration for `bind` implies that `x` is in scope in
+ `e₂`, but not in `e₁`.
+
+ You can give fixity declarations along with syntax declarations:
+
+ ```agda
+ infixr 40 bind
+ syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂
+ ```
+
+ The fixity applies to the syntax, not the name; syntax declarations
+ are also restricted to ordinary, non-operator names. The following
+ declaration is disallowed:
+
+ ```agda
+ syntax _==_ x y = x === y
+ ```agda
+
+ Syntax declarations must also be linear; the following declaration
+ is disallowed:
+
+ ```agda
+ syntax wrong x = x + x
+ ```
+
+ Syntax declarations were added very recently, and have not been
+ subjected to much experimentation yet, so do not be surprised if
+ something is changed before the next release.
+
+* `Prop` has been removed from the language.
+
+ The experimental sort `Prop` has been disabled. Any program using
+ `Prop` should typecheck if `Prop` is replaced by `Set₀`. Note that
+ `Prop` is still a keyword.
+
+* Injective type constructors off by default.
+
+ Automatic injectivity of type constructors has been disabled (by
+ default). To enable it, use the flag
+ `--injective-type-constructors`, either on the command line or in an
+ OPTIONS pragma. Note that this flag makes Agda anti-classical and
+ possibly inconsistent:
+
+ Agda with excluded middle is inconsistent
+ http://thread.gmane.org/gmane.comp.lang.agda/1367
+
+ See `test/Succeed/InjectiveTypeConstructors.agda` for an example.
+
+* Termination checker can count.
+
+ There is a new flag `--termination-depth=N` accepting values `N >=
+ 1` (with `N = 1` being the default) which influences the behavior of
+ the termination checker. So far, the termination checker has only
+ distinguished three cases when comparing the argument of a recursive
+ call with the formal parameter of the callee.
+
+ `<`: the argument is structurally smaller than the parameter
+
+ `=`: they are equal
+
+ `?`: the argument is bigger or unrelated to the parameter
+
+ This behavior, which is still the default (`N = 1`), will not
+ recognise the following functions as terminating.
+
+ ```agda
+ mutual
+
+ f : ℕ → ℕ
+ f zero = zero
+ f (suc zero) = zero
+ f (suc (suc n)) = aux n
+
+ aux : ℕ → ℕ
+ aux m = f (suc m)
+ ```
+
+ The call graph
+
+ ```
+ f --(<)--> aux --(?)--> f
+ ```
+
+ yields a recursive call from `f` to `f` via `aux` where the relation
+ of call argument to callee parameter is computed as "unrelated"
+ (composition of `<` and `?`).
+
+ Setting `N >= 2` allows a finer analysis: `n` has two constructors
+ less than `suc (suc n)`, and `suc m` has one more than `m`, so we get the
+ call graph:
+
+ ```
+ f --(-2)--> aux --(+1)--> f
+ ```
+
+ The indirect call `f --> f` is now labeled with `(-1)`, and the
+ termination checker can recognise that the call argument is
+ decreasing on this path.
+
+ Setting the termination depth to `N` means that the termination
+ checker counts decrease up to `N` and increase up to `N-1`. The
+ default, `N=1`, means that no increase is counted, every increase
+ turns to "unrelated".
+
+ In practice, examples like the one above sometimes arise when `with`
+ is used. As an example, the program
+
+ ```agda
+ f : ℕ → ℕ
+ f zero = zero
+ f (suc zero) = zero
+ f (suc (suc n)) with zero
+ ... | _ = f (suc n)
+ ```
+
+ is internally represented as
+
+ ```agda
+ mutual
+
+ f : ℕ → ℕ
+ f zero = zero
+ f (suc zero) = zero
+ f (suc (suc n)) = aux n zero
+
+ aux : ℕ → ℕ → ℕ
+ aux m k = f (suc m)
+ ```
+
+ Thus, by default, the definition of `f` using `with` is not accepted
+ by the termination checker, even though it looks structural (`suc n`
+ is a subterm of `suc suc n`). Now, the termination checker is
+ satisfied if the option `--termination-depth=2` is used.
+
+ Caveats:
+
+ - This is an experimental feature, hopefully being replaced by
+ something smarter in the near future.
+
+ - Increasing the termination depth will quickly lead to very long
+ termination checking times. So, use with care. Setting termination
+ depth to `100` by habit, just to be on the safe side, is not a good
+ idea!
+
+ - Increasing termination depth only makes sense for linear data
+ types such as `ℕ` and `Size`. For other types, increase cannot be
+ recognised. For instance, consider a similar example with lists.
+
+ ```agda
+ data List : Set where
+ nil : List
+ cons : ℕ → List → List
+
+ mutual
+ f : List → List
+ f nil = nil
+ f (cons x nil) = nil
+ f (cons x (cons y ys)) = aux y ys
+
+ aux : ℕ → List → List
+ aux z zs = f (cons z zs)
+ ```
+
+ Here the termination checker compares `cons z zs` to `z` and also
+ to `zs`. In both cases, the result will be "unrelated", no matter
+ how high we set the termination depth. This is because when
+ comparing `cons z zs` to `zs`, for instance, `z` is unrelated to
+ `zs`, thus, `cons z zs` is also unrelated to `zs`. We cannot say
+ it is just "one larger" since `z` could be a very large term. Note
+ that this points to a weakness of untyped termination checking.
+
+ To regain the benefit of increased termination depth, we need to
+ index our lists by a linear type such as `ℕ` or `Size`. With
+ termination depth `2`, the above example is accepted for vectors
+ instead of lists.
+
+* The `codata` keyword has been removed. To use coinduction, use the
+ following new builtins: `INFINITY`, `SHARP` and `FLAT`. Example:
+
+ ```agda
+ {-# OPTIONS --universe-polymorphism #-}
+
+ module Coinduction where
+
+ open import Level
+
+ infix 1000 ♯_
+
+ postulate
+ ∞ : ∀ {a} (A : Set a) → Set a
+ ♯_ : ∀ {a} {A : Set a} → A → ∞ A
+ ♭ : ∀ {a} {A : Set a} → ∞ A → A
+
+ {-# BUILTIN INFINITY ∞ #-}
+ {-# BUILTIN SHARP ♯_ #-}
+ {-# BUILTIN FLAT ♭ #-}
+ ```
+
+ Note that (non-dependent) pattern matching on `SHARP` is no longer
+ allowed.
+
+ Note also that strange things might happen if you try to combine the
+ pragmas above with `COMPILED_TYPE`, `COMPILED_DATA` or `COMPILED`
+ pragmas, or if the pragmas do not occur right after the postulates.
+
+ The compiler compiles the `INFINITY` builtin to nothing (more or
+ less), so that the use of coinduction does not get in the way of FFI
+ declarations:
+
+ ```agda
+ data Colist (A : Set) : Set where
+ [] : Colist A
+ _∷_ : (x : A) (xs : ∞ (Colist A)) → Colist A
+
+ {-# COMPILED_DATA Colist [] [] (:) #-}
+ ```
+
+* Infinite types.
+
+ If the new flag `--guardedness-preserving-type-constructors` is
+ used, then type constructors are treated as inductive constructors
+ when we check productivity (but only in parameters, and only if they
+ are used strictly positively or not at all). This makes examples
+ such as the following possible:
+
+ ```agda
+ data Rec (A : ∞ Set) : Set where
+ fold : ♭ A → Rec A
+
+ -- Σ cannot be a record type below.
+
+ data Σ (A : Set) (B : A → Set) : Set where
+ _,_ : (x : A) → B x → Σ A B
+
+ syntax Σ A (λ x → B) = Σ[ x ∶ A ] B
+
+ -- Corecursive definition of the W-type.
+
+ W : (A : Set) → (A → Set) → Set
+ W A B = Rec (♯ (Σ[ x ∶ A ] (B x → W A B)))
+
+ syntax W A (λ x → B) = W[ x ∶ A ] B
+
+ sup : {A : Set} {B : A → Set} (x : A) (f : B x → W A B) → W A B
+ sup x f = fold (x , f)
+
+ W-rec : {A : Set} {B : A → Set}
+ (P : W A B → Set) →
+ (∀ {x} {f : B x → W A B} → (∀ y → P (f y)) → P (sup x f)) →
+ ∀ x → P x
+ W-rec P h (fold (x , f)) = h (λ y → W-rec P h (f y))
+
+ -- Induction-recursion encoded as corecursion-recursion.
+
+ data Label : Set where
+ ′0 ′1 ′2 ′σ ′π ′w : Label
+
+ mutual
+
+ U : Set
+ U = Σ Label U′
+
+ U′ : Label → Set
+ U′ ′0 = ⊤
+ U′ ′1 = ⊤
+ U′ ′2 = ⊤
+ U′ ′σ = Rec (♯ (Σ[ a ∶ U ] (El a → U)))
+ U′ ′π = Rec (♯ (Σ[ a ∶ U ] (El a → U)))
+ U′ ′w = Rec (♯ (Σ[ a ∶ U ] (El a → U)))
+
+ El : U → Set
+ El (′0 , _) = ⊥
+ El (′1 , _) = ⊤
+ El (′2 , _) = Bool
+ El (′σ , fold (a , b)) = Σ[ x ∶ El a ] El (b x)
+ El (′π , fold (a , b)) = (x : El a) → El (b x)
+ El (′w , fold (a , b)) = W[ x ∶ El a ] El (b x)
+
+ U-rec : (P : ∀ u → El u → Set) →
+ P (′1 , _) tt →
+ P (′2 , _) true →
+ P (′2 , _) false →
+ (∀ {a b x y} →
+ P a x → P (b x) y → P (′σ , fold (a , b)) (x , y)) →
+ (∀ {a b f} →
+ (∀ x → P (b x) (f x)) → P (′π , fold (a , b)) f) →
+ (∀ {a b x f} →
+ (∀ y → P (′w , fold (a , b)) (f y)) →
+ P (′w , fold (a , b)) (sup x f)) →
+ ∀ u (x : El u) → P u x
+ U-rec P P1 P2t P2f Pσ Pπ Pw = rec
+ where
+ rec : ∀ u (x : El u) → P u x
+ rec (′0 , _) ()
+ rec (′1 , _) _ = P1
+ rec (′2 , _) true = P2t
+ rec (′2 , _) false = P2f
+ rec (′σ , fold (a , b)) (x , y) = Pσ (rec _ x) (rec _ y)
+ rec (′π , fold (a , b)) f = Pπ (λ x → rec _ (f x))
+ rec (′w , fold (a , b)) (fold (x , f)) = Pw (λ y → rec _ (f y))
+ ```
+
+ The `--guardedness-preserving-type-constructors` extension is based
+ on a rather operational understanding of `∞`/`♯_`; it's not yet
+ clear if this extension is consistent.
+
+* Qualified constructors.
+
+ Constructors can now be referred to qualified by their data type.
+ For instance, given
+
+ ```agda
+ data Nat : Set where
+ zero : Nat
+ suc : Nat → Nat
+
+ data Fin : Nat → Set where
+ zero : ∀ {n} → Fin (suc n)
+ suc : ∀ {n} → Fin n → Fin (suc n)
+ ```
+
+ you can refer to the constructors unambiguously as `Nat.zero`,
+ `Nat.suc`, `Fin.zero`, and `Fin.suc` (`Nat` and `Fin` are modules
+ containing the respective constructors). Example:
+
+ ```agda
+ inj : (n m : Nat) → Nat.suc n ≡ suc m → n ≡ m
+ inj .m m refl = refl
+ ```
+
+ Previously you had to write something like
+
+ ```agda
+ inj : (n m : Nat) → _≡_ {Nat} (suc n) (suc m) → n ≡ m
+ ```
+
+ to make the type checker able to figure out that you wanted the
+ natural number suc in this case.
+
+* Reflection.
+
+ There are two new constructs for reflection:
+
+ - `quoteGoal x in e`
+
+ In `e` the value of `x` will be a representation of the goal type
+ (the type expected of the whole expression) as an element in a
+ datatype of Agda terms (see below). For instance,
+
+ ```agda
+ example : ℕ
+ example = quoteGoal x in {! at this point x = def (quote ℕ) [] !}
+ ```
+
+ - `quote x : Name`
+
+ If `x` is the name of a definition (function, datatype, record,
+ or a constructor), `quote x` gives you the representation of `x`
+ as a value in the primitive type `Name` (see below).
+
+ Quoted terms use the following BUILTINs and primitives (available
+ from the standard library module `Reflection`):
+
+ ```agda
+ -- The type of Agda names.
+
+ postulate Name : Set
+
+ {-# BUILTIN QNAME Name #-}
+
+ primitive primQNameEquality : Name → Name → Bool
+
+ -- Arguments.
+
+ Explicit? = Bool
+
+ data Arg A : Set where
+ arg : Explicit? → A → Arg A
+
+ {-# BUILTIN ARG Arg #-}
+ {-# BUILTIN ARGARG arg #-}
+
+ -- The type of Agda terms.
+
+ data Term : Set where
+ var : ℕ → List (Arg Term) → Term
+ con : Name → List (Arg Term) → Term
+ def : Name → List (Arg Term) → Term
+ lam : Explicit? → Term → Term
+ pi : Arg Term → Term → Term
+ sort : Term
+ unknown : Term
+
+ {-# BUILTIN AGDATERM Term #-}
+ {-# BUILTIN AGDATERMVAR var #-}
+ {-# BUILTIN AGDATERMCON con #-}
+ {-# BUILTIN AGDATERMDEF def #-}
+ {-# BUILTIN AGDATERMLAM lam #-}
+ {-# BUILTIN AGDATERMPI pi #-}
+ {-# BUILTIN AGDATERMSORT sort #-}
+ {-# BUILTIN AGDATERMUNSUPPORTED unknown #-}
+ ```
+
+ Reflection may be useful when working with internal decision
+ procedures, such as the standard library's ring solver.
+
+* Minor record definition improvement.
+
+ The definition of a record type is now available when type checking
+ record module definitions. This means that you can define things
+ like the following:
+
+ ```agda
+ record Cat : Set₁ where
+ field
+ Obj : Set
+ _=>_ : Obj → Obj → Set
+ -- ...
+
+ -- not possible before:
+ op : Cat
+ op = record { Obj = Obj; _=>_ = λ A B → B => A }
+ ```
+
+Tools
+-----
+
+* The `Goal type and context` command now shows the goal type before
+ the context, and the context is shown in reverse order. The `Goal
+ type, context and inferred type` command has been modified in a
+ similar way.
+
+* Show module contents command.
+
+ Given a module name `M` the Emacs mode can now display all the
+ top-level modules and names inside `M`, along with types for the
+ names. The command is activated using `C-c C-o` or the menus.
+
+* Auto command.
+
+ A command which searches for type inhabitants has been added. The
+ command is invoked by pressing `C-C C-a` (or using the goal menu).
+ There are several flags and parameters, e.g. `-c` which enables
+ case-splitting in the search. For further information, see the Agda
+ wiki:
+
+ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Auto
+
+* HTML generation is now possible for a module with unsolved
+ meta-variables, provided that the `--allow-unsolved-metas` flag is
+ used.
+
+Release notes for Agda 2 version 2.2.6
+======================================
+
+Language
+--------
+
+* Universe polymorphism (experimental extension).
+
+ To enable universe polymorphism give the flag
+ `--universe-polymorphism` on the command line or (recommended) as an
+ OPTIONS pragma.
+
+ When universe polymorphism is enabled `Set` takes an argument which is
+ the universe level. For instance, the type of universe polymorphic
+ identity is
+
+ ```agda
+ id : {a : Level} {A : Set a} → A → A.
+ ```
+
+ The type Level is isomorphic to the unary natural numbers and should
+ be specified using the BUILTINs `LEVEL`, `LEVELZERO`, and
+ `LEVELSUC`:
+
+ ```agda
+ data Level : Set where
+ zero : Level
+ suc : Level → Level
+
+ {-# BUILTIN LEVEL Level #-}
+ {-# BUILTIN LEVELZERO zero #-}
+ {-# BUILTIN LEVELSUC suc #-}
+ ```
+
+ There is an additional BUILTIN `LEVELMAX` for taking the maximum of two
+ levels:
+
+ ```agda
+ max : Level → Level → Level
+ max zero m = m
+ max (suc n) zero = suc n
+ max (suc n) (suc m) = suc (max n m)
+
+ {-# BUILTIN LEVELMAX max #-}
+ ```
+
+ The non-polymorphic universe levels `Set`, `Set₁` and so on are
+ sugar for `Set zero`, `Set (suc zero)`, etc.
+
+ At present there is no automatic lifting of types from one level to
+ another. It can still be done (rather clumsily) by defining types
+ like the following one:
+
+ ```agda
+ data Lifted {a} (A : Set a) : Set (suc a) where
+ lift : A → Lifted A
+ ```
+
+ However, it is likely that automatic lifting is introduced at some
+ point in the future.
+
+* Multiple constructors, record fields, postulates or primitives can
+ be declared using a single type signature:
+
+ ```agda
+ data Bool : Set where
+ false true : Bool
+
+ postulate
+ A B : Set
+ ```
+
+* Record fields can be implicit:
+
+ ```agda
+ record R : Set₁ where
+ field
+ {A} : Set
+ f : A → A
+ {B C} D {E} : Set
+ g : B → C → E
+ ```
+
+ By default implicit fields are not printed.
+
+* Record constructors can be defined:
+
+ ```agda
+ record Σ (A : Set) (B : A → Set) : Set where
+ constructor _,_
+ field
+ proj₁ : A
+ proj₂ : B proj₁
+ ```
+
+ In this example `_,_` gets the type
+
+ ```agda
+ (proj₁ : A) → B proj₁ → Σ A B.
+ ```
+
+ For implicit fields the corresponding constructor arguments become
+ implicit.
+
+ Note that the constructor is defined in the *outer* scope, so any
+ fixity declaration has to be given outside the record definition.
+ The constructor is not in scope inside the record module.
+
+ Note also that pattern matching for records has not been implemented
+ yet.
+
+* BUILTIN hooks for equality.
+
+ The data type
+
+ ```agda
+ data _≡_ {A : Set} (x : A) : A → Set where
+ refl : x ≡ x
+ ```
+
+ can be specified as the builtin equality type using the following
+ pragmas:
+
+ ```agda
+ {-# BUILTIN EQUALITY _≡_ #-}
+ {-# BUILTIN REFL refl #-}
+ ```
+
+ The builtin equality is used for the new rewrite construct and
+ the `primTrustMe` primitive described below.
+
+* New `rewrite` construct.
+
+ If `eqn : a ≡ b`, where `_≡_` is the builtin equality (see above) you
+ can now write
+
+ ```agda
+ f ps rewrite eqn = rhs
+ ```
+
+ instead of
+
+ ```agda
+ f ps with a | eqn
+ ... | ._ | refl = rhs
+ ```
+
+ The `rewrite` construct has the effect of rewriting the goal and the
+ context by the given equation (left to right).
+
+ You can rewrite using several equations (in sequence) by separating
+ them with vertical bars (|):
+
+ ```agda
+ f ps rewrite eqn₁ | eqn₂ | … = rhs
+ ```
+
+ It is also possible to add `with`-clauses after rewriting:
+
+ ```agda
+ f ps rewrite eqns with e
+ ... | p = rhs
+ ```
+
+ Note that pattern matching happens before rewriting—if you want to
+ rewrite and then do pattern matching you can use a with after the
+ rewrite.
+
+ See `test/Succeed/Rewrite.agda` for some examples.
+
+* A new primitive, `primTrustMe`, has been added:
+
+ ```agda
+ primTrustMe : {A : Set} {x y : A} → x ≡ y
+ ```
+
+ Here `_≡_` is the builtin equality (see BUILTIN hooks for equality,
+ above).
+
+ If `x` and `y` are definitionally equal, then
+ `primTrustMe {x = x} {y = y}` reduces to `refl`.
+
+ Note that the compiler replaces all uses of `primTrustMe` with the
+ `REFL` builtin, without any check for definitional
+ equality. Incorrect uses of `primTrustMe` can potentially lead to
+ segfaults or similar problems.
+
+ For an example of the use of `primTrustMe`, see `Data.String` in
+ version 0.3 of the standard library, where it is used to implement
+ decidable equality on strings using the primitive boolean equality.
+
+* Changes to the syntax and semantics of IMPORT pragmas, which are
+ used by the Haskell FFI. Such pragmas must now have the following
+ form:
+
+ ```agda
+ {-# IMPORT <module name> #-}
+ ```
+
+ These pragmas are interpreted as *qualified* imports, so Haskell
+ names need to be given qualified (unless they come from the Haskell
+ prelude).
+
+* The horizontal tab character (U+0009) is no longer treated as white
+ space.
+
+* Line pragmas are no longer supported.
+
+* The `--include-path` flag can no longer be used as a pragma.
+
+* The experimental and incomplete support for proof irrelevance has
+ been disabled.
+
+Tools
+-----
+
+* New `intro` command in the Emacs mode. When there is a canonical way
+ of building something of the goal type (for instance, if the goal
+ type is a pair), the goal can be refined in this way. The command
+ works for the following goal types:
+
+ - A data type where only one of its constructors can be used to
+ construct an element of the goal type. (For instance, if the
+ goal is a non-empty vector, a `cons` will be introduced.)
+
+ - A record type. A record value will be introduced. Implicit
+ fields will not be included unless showing of implicit arguments
+ is switched on.
+
+ - A function type. A lambda binding as many variables as possible
+ will be introduced. The variable names will be chosen from the
+ goal type if its normal form is a dependent function type,
+ otherwise they will be variations on `x`. Implicit lambdas will
+ only be inserted if showing of implicit arguments is switched
+ on.
+
+ This command can be invoked by using the `refine` command
+ (`C-c C-r`) when the goal is empty. (The old behaviour of the refine
+ command in this situation was to ask for an expression using the
+ minibuffer.)
+
+* The Emacs mode displays `Checked` in the mode line if the current
+ file type checked successfully without any warnings.
+
+* If a file `F` is loaded, and this file defines the module `M`, it is
+ an error if `F` is not the file which defines `M` according to the
+ include path.
+
+ Note that the command-line tool and the Emacs mode define the
+ meaning of relative include paths differently: the command-line tool
+ interprets them relative to the current working directory, whereas
+ the Emacs mode interprets them relative to the root directory of the
+ current project. (As an example, if the module `A.B.C` is loaded
+ from the file `<some-path>/A/B/C.agda`, then the root directory is
+ `<some-path>`.)
+
+* It is an error if there are several files on the include path which
+ match a given module name.
+
+* Interface files are relocatable. You can move around source trees as
+ long as the include path is updated in a corresponding way. Note
+ that a module `M` may be re-typechecked if its time stamp is
+ strictly newer than that of the corresponding interface file
+ (`M.agdai`).
+
+* Type-checking is no longer done when an up-to-date interface exists.
+ (Previously the initial module was always type-checked.)
+
+* Syntax highlighting files for Emacs (`.agda.el`) are no longer used.
+ The `--emacs` flag has been removed. (Syntax highlighting
+ information is cached in the interface files.)
+
+* The Agate and Alonzo compilers have been retired. The options
+ `--agate`, `--alonzo` and `--malonzo` have been removed.
+
+* The default directory for MAlonzo output is the project's root
+ directory. The `--malonzo-dir` flag has been renamed to
+ `--compile-dir`.
+
+* Emacs mode: `C-c C-x C-d` no longer resets the type checking state.
+ `C-c C-x C-r` can be used for a more complete reset. `C-c C-x C-s`
+ (which used to reload the syntax highlighting information) has been
+ removed. `C-c C-l` can be used instead.
+
+* The Emacs mode used to define some "abbrevs", unless the user
+ explicitly turned this feature off. The new default is *not* to add
+ any abbrevs. The old default can be obtained by customising
+ `agda2-mode-abbrevs-use-defaults` (a customisation buffer can be
+ obtained by typing `M-x customize-group agda2 RET` after an Agda
+ file has been loaded).
+
+Release notes for Agda 2 version 2.2.4
+======================================
+
+Important changes since 2.2.2:
+
+* Change to the semantics of `open import` and `open module`. The
+ declaration
+
+ ```agda
+ open import M <using/hiding/renaming>
+ ```
+
+ now translates to
+
+ ```agda
+ import A
+ open A <using/hiding/renaming>
+ ```
+
+ instead of
+
+ ```agda
+ import A <using/hiding/renaming>
+ open A
+ ```
+
+ The same translation is used for `open module M = E …`. Declarations
+ involving the keywords as or public are changed in a corresponding
+ way (`as` always goes with import, and `public` always with open).
+
+ This change means that import directives do not affect the qualified
+ names when open import/module is used. To get the old behaviour you
+ can use the expanded version above.
+
+* Names opened publicly in parameterised modules no longer inherit the
+ module parameters. Example:
+
+ ```agda
+ module A where
+ postulate X : Set
+
+ module B (Y : Set) where
+ open A public
+ ```
+
+ In Agda 2.2.2 `B.X` has type `(Y : Set) → Set`, whereas in
+ Agda 2.2.4 `B.X` has type Set.
+
+* Previously it was not possible to export a given constructor name
+ through two different `open public` statements in the same module.
+ This is now possible.
+
+* Unicode subscript digits are now allowed for the hierarchy of
+ universes (`Set₀`, `Set₁`, …): `Set₁` is equivalent to `Set1`.
+
+Release notes for Agda 2 version 2.2.2
+======================================
+
+Tools
+-----
+
+* The `--malonzodir` option has been renamed to `--malonzo-dir`.
+
+* The output of `agda --html` is by default placed in a directory
+ called `html`.
+
+Infrastructure
+--------------
+
+* The Emacs mode is included in the Agda Cabal package, and installed
+ by `cabal install`. The recommended way to enable the Emacs mode is
+ to include the following code in `.emacs`:
+
+ ```elisp
+ (load-file (let ((coding-system-for-read 'utf-8))
+ (shell-command-to-string "agda-mode locate")))
+ ```
+
+Release notes for Agda 2 version 2.2.0
+======================================
+
+Important changes since 2.1.2 (which was released 2007-08-16):
+
+Language
+--------
+
+* Exhaustive pattern checking. Agda complains if there are missing
+ clauses in a function definition.
+
+* Coinductive types are supported. This feature is under
+ development/evaluation, and may change.
+
+ http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.Codatatypes
+
+* Another experimental feature: Sized types, which can make it easier
+ to explain why your code is terminating.
+
+* Improved constraint solving for functions with constructor headed
+ right hand sides.
+
+ http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.FindingTheValuesOfImplicitArguments
+
+* A simple, well-typed foreign function interface, which allows use of
+ Haskell functions in Agda code.
+
+ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.FFI
+
+* The tokens `forall`, `->` and `\` can be written as `∀`, `→` and
+ `λ`.
+
+* Absurd lambdas: `λ ()` and `λ {}`.
+
+ http://thread.gmane.org/gmane.comp.lang.agda/440
+
+* Record fields whose values can be inferred can be omitted.
+
+* Agda complains if it spots an unreachable clause, or if a pattern
+ variable "shadows" a hidden constructor of matching type.
+
+ http://thread.gmane.org/gmane.comp.lang.agda/720
+
+Tools
+-----
+
+* Case-split: The user interface can replace a pattern variable with
+ the corresponding constructor patterns. You get one new left-hand
+ side for every possible constructor.
+
+ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.QuickGuideToEditingTypeCheckingAndCompilingAgdaCode
+
+* The MAlonzo compiler.
+
+ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.MAlonzo
+
+* A new Emacs input method, which contains bindings for many Unicode
+ symbols, is by default activated in the Emacs mode.
+
+ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.UnicodeInput
+
+* Highlighted, hyperlinked HTML can be generated from Agda source
+ code.
+
+ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.HowToGenerateWebPagesFromSourceCode
+
+* The command-line interactive mode (`agda -I`) is no longer
+ supported, but should still work.
+
+ http://thread.gmane.org/gmane.comp.lang.agda/245
+
+* Reload times when working on large projects are now considerably
+ better.
+
+ http://thread.gmane.org/gmane.comp.lang.agda/551
+
+Libraries
+---------
+
+* A standard library is under development.
+
+ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Libraries.StandardLibrary
+
+Documentation
+-------------
+
+* The Agda wiki is better organised. It should be easier for a
+ newcomer to find relevant information now.
+
+ http://wiki.portal.chalmers.se/agda/
+
+Infrastructure
+--------------
+
+* Easy-to-install packages for Windows and Debian/Ubuntu have been
+ prepared.
+
+ http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Download
+
+* Agda 2.2.0 is available from Hackage.
+
+ http://hackage.haskell.org/
diff --git a/README.md b/README.md
index 146652e..2e5d95b 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,13 @@
Agda 2
======
-[![Hackage](https://img.shields.io/hackage/v/Agda.svg)](http://hackage.haskell.org/package/Agda) [![Build Status](https://travis-ci.org/agda/agda.svg?branch=master)](https://travis-ci.org/agda/agda)
+[![Hackage version](https://img.shields.io/hackage/v/Agda.svg?label=Hackage)](http://hackage.haskell.org/package/Agda)
+[![Stackage version](https://www.stackage.org/package/Agda/badge/lts?label=Stackage)](https://www.stackage.org/package/Agda)
+[![Build Status](https://travis-ci.org/agda/agda.svg?branch=stable-2.5)](https://travis-ci.org/agda/agda)
Table of contents:
+* [Documentation](#documentation)
* [Prerequisites](#prerequisites)
* [Installing Agda](#installing-agda)
* [Configuring the Emacs mode](#configuring-the-emacs-mode)
@@ -13,6 +16,11 @@ Table of contents:
Note that this README only discusses installation of Agda, not its standard
library. See the [Agda Wiki][agdawiki] for information about the library.
+Documentation
+-------------
+
+* [User manual](http://agda.readthedocs.io)
+* [CHANGELOG](https://github.com/agda/agda/blob/master/CHANGELOG.md)
Prerequisites
-------------
@@ -23,6 +31,7 @@ You need recent versions of the following programs/libraries:
* cabal-install: http://www.haskell.org/cabal/
* Alex: http://www.haskell.org/alex/
* Happy: http://www.haskell.org/happy/
+* cpphs: http://projects.haskell.org/cpphs/
* GNU Emacs: http://www.gnu.org/software/emacs/
You should also make sure that programs installed by cabal-install are
diff --git a/dist/build/Agda/Syntax/Parser/Lexer.hs b/dist/build/Agda/Syntax/Parser/Lexer.hs
index b4dee9d..d95a535 100644
--- a/dist/build/Agda/Syntax/Parser/Lexer.hs
+++ b/dist/build/Agda/Syntax/Parser/Lexer.hs
@@ -17,7 +17,7 @@ module Agda.Syntax.Parser.Lexer
( -- * The main function
lexer
-- * Lex states
- , normal, literate, code
+ , normal, code
, layout, empty_layout, bol, imp_dir
-- * Alex generated functions
, AlexReturn(..), alexScanUser
@@ -56,25 +56,22 @@ import GlaExts
alex_tab_size :: Int
alex_tab_size = 8
alex_base :: AlexAddr
-alex_base = AlexA# "\xf7\xff\xff\xff\x6c\x00\x00\x00\xe1\x00\x00\x00\x55\x01\x00\x00\xca\x01\x00\x00\x3f\x02\x00\x00\xb5\x02\x00\x00\xab\x03\x00\x00\x88\xff\xff\xff\xd9\xff\xff\xff\x8a\x04\x00\x00\xe8\x04\x00\x00\x46\x05\x00\x00\xb6\x02\x00\x00\xa2\x05\x00\x00\x9d\x03\x00\x00\xfe\x05\x00\x00\xfd\x05\x00\x00\x7d\x06\x00\x00\xa2\xff\xff\xff\xfd\x06\x00\x00\xdc\x07\x00\x00\xdb\x07\x00\x00\x5b\x08\x00\x00\xdb\x08\x00\x00\x5b\x09\x00\x00\x3a\x0a\x00\x00\x96\x0a\x00\x00\xf2\x0a\x00\x00\xf1\x0a\x00\x00\x99\xff\xff\xff\xa6\xff\xff\xff\x8f\xff\xff\xff\x9d\xff\xff\xff\xa8\xff\xff\xff\x00\x00\x00\x00\x62\x0b\x00\x00\x00\x00\x00\x00\xd3\x0b\x00\x00\xa9\xff\xff\xff\x00\x00\x00\x00\x44\x0c\x00\x00\x00\x00\x00\x00\xb5\x0c\x00\x00\x00\x00\x00\x00\xf6\x0c\x00\x00\x00\x00\x00\x00\x37\x0d\x00\x00\x00\x00\x00\x00\x78\x0d\x00\x00\x00\x00\x00\x00\xb9\x0d\x00\x00\x98\x0e\x00\x00\x17\x0f\x00\x00\xd7\x0e\x00\x00\x00\x00\x00\x00\xd7\x0f\x00\x00\x97\x0f\x00\x00\x00\x00\x00\x00\x97\x10\x00\x00\x57\x10\x00\x00\x00\x00\x00\x00\x57\x11\x00\x00\x04\x00\x00\x00\xcd\x11\x00\x00\x2f\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x12\x00\x00\xb9\x13\x00\x00\xaf\x14\x00\x00\xa5\x15\x00\x00\x9b\x16\x00\x00\x91\x17\x00\x00\x87\x18\x00\x00\x7d\x19\x00\x00\x73\x1a\x00\x00\x69\x1b\x00\x00\x5f\x1c\x00\x00\x55\x1d\x00\x00\x4b\x1e\x00\x00\x41\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x20\x00\x00\x2f\x21\x00\x00\x26\x22\x00\x00\x1d\x23\x00\x00\x14\x24\x00\x00\x0b\x25\x00\x00\x02\x26\x00\x00\xf9\x26\x00\x00\xf0\x27\x00\x00\xe7\x28\x00\x00\xde\x29\x00\x00\xd5\x2a\x00\x00\xcc\x2b\x00\x00\xc3\x2c\x00\x00\xba\x2d\x00\x00\xb1\x2e\x00\x00\xa8\x2f\x00\x00\x9f\x30\x00\x00\x96\x31\x00\x00\x8d\x32\x00\x00\x84\x33\x00\x00\x7b\x34\x00\x00\x72\x35\x00\x00\x69\x36\x00\x00\x60\x37\x00\x00\x57\x38\x00\x00\x4e\x39\x00\x00\x45\x3a\x00\x00\x3c\x3b\x00\x00\x33\x3c\x00\x00\x2a\x3d\x00\x00\x21\x3e\x00\x00\x18\x3f\x00\x00\x0f\x40\x00\x00\x06\x41\x00\x00\xfd\x41\x00\x00\xf4\x42\x00\x00\xeb\x43\x00\x00\xe2\x44\x00\x00\xd9\x45\x00\x00\xd0\x46\x00\x00\xc7\x47\x00\x00\xbe\x48\x00\x00\xb5\x49\x00\x00\xac\x4a\x00\x00\xa3\x4b\x00\x00\x9a\x4c\x00\x00\x91\x4d\x00\x00\x88\x4e\x00\x00\x7f\x4f\x00\x00\x76\x50\x00\x00\x6d\x51\x00\x00\x64\x52\x00\x00\x5b\x53\x00\x00\x52\x54\x00\x00\x49\x55\x00\x00\x40\x56\x00\x00\x37\x57\x00\x00\x2e\x58\x00\x00\x25\x59\x00\x00\x1c\x5a\x00\x00\x13\x5b\x00\x00\x0a\x5c\x00\x00\x01\x5d\x00\x00\xf8\x5d\x00\x00\xef\x5e\x00\x00\xe6\x5f\x00\x00\xdd\x60\x00\x00\xd4\x61\x00\x00\xcb\x62\x00\x00\xc2\x63\x00\x00\xb9\x64\x00\x00\xb0\x65\x00\x00\xa7\x66\x00\x00\x9e\x67\x00\x00\x95\x68\x00\x00\x8c\x69\x00\x00\x83\x6a\x00\x00\x7a\x6b\x00\x00\x71\x6c\x00\x00\x68\x6d\x00\x00\x5f\x6e\x00\x00\x56\x6f\x00\x00\x4d\x70\x00\x00\x44\x71\x00\x00\x3b\x72\x00\x00\x32\x73\x00\x00\x29\x74\x00\x00\x20\x75\x00\x00\x17\x76\x00\x00\x0e\x77\x00\x00\x05\x78\x00\x00\xfc\x78\x00\x00\xf3\x79\x00\x00\xea\x7a\x00\x00\xe1\x7b\x00\x00\xd8\x7c\x00\x00\xcf\x7d\x00\x00\xc6\x7e\x00\x00\xbd\x7f\x00\x00\xb4\x80\x00\x00\xab\x81\x00\x00\xa2\x82\x00\x00\x99\x83\x00\x00\x90\x84\x00\x00\x87\x85\x00\x00\x7e\x86\x00\x00\x75\x87\x00\x00\x6c\x88\x00\x00\x63\x89\x00\x00\x5a\x8a\x00\x00\x51\x8b\x00\x00\x48\x8c\x00\x00\x3f\x8d\x00\x00\x36\x8e\x00\x00\x2d\x8f\x00\x00\x24\x90\x00\x00\x1b\x91\x00\x00\x12\x92\x00\x00\x09\x93\x00\x00\x00\x94\x00\x00\xf7\x94\x00\x00\xee\x95\x00\x00\xe5\x96\x00\x00\xdc\x97\x00\x00\xd3\x98\x00\x00\xca\x99\x00\x00\xc1\x9a\x00\x00\xb8\x9b\x00\x00\xaf\x9c\x00\x00\xa6\x9d\x00\x00\x9d\x9e\x00\x00\x94\x9f\x00\x00\x8b\xa0\x00\x00\x82\xa1\x00\x00\x79\xa2\x00\x00\x70\xa3\x00\x00\x67\xa4\x00\x00\x5e\xa5\x00\x00\x55\xa6\x00\x00\x4c\xa7\x00\x00\x43\xa8\x00\x00\x3a\xa9\x00\x00\x31\xaa\x00\x00\x28\xab\x00\x00\x1f\xac\x00\x00\x16\xad\x00\x00\x0d\xae\x00\x00\x04\xaf\x00\x00\xfb\xaf\x00\x00\xf2\xb0\x00\x00\xe9\xb1\x00\x00\xe0\xb2\x00\x00\xd7\xb3\x00\x00\xce\xb4\x00\x00\xc5\xb5\x00\x00\xbc\xb6\x00\x00\xb3\xb7\x00\x00\xaa\xb8\x00\x00\xa1\xb9\x00\x00\x98\xba\x00\x00\x8f\xbb\x00\x00\x86\xbc\x00\x00\x7d\xbd\x00\x00\x74\xbe\x00\x00\x6b\xbf\x00\x00\x62\xc0\x00\x00\x59\xc1\x00\x00\x50\xc2\x00\x00\x47\xc3\x00\x00\x3e\xc4\x00\x00\x35\xc5\x00\x00\x2c\xc6\x00\x00\x23\xc7\x00\x00\x1a\xc8\x00\x00\x11\xc9\x00\x00\x08\xca\x00\x00\xff\xca\x00\x00\xf6\xcb\x00\x00\xed\xcc\x00\x00\xe4\xcd\x00\x00\xdb\xce\x00\x00\xd2\xcf\x00\x00\xc9\xd0\x00\x00\xc0\xd1\x00\x00\xb7\xd2\x00\x00\xae\xd3\x00\x00\xa5\xd4\x00\x00\x9c\xd5\x00\x00\x93\xd6\x00\x00\x8a\xd7\x00\x00\x81\xd8\x00\x00\x78\xd9\x00\x00\x6f\xda\x00\x00\x66\xdb\x00\x00\x5d\xdc\x00\x00\x54\xdd\x00\x00\x4b\xde\x00\x00\x42\xdf\x00\x00\x39\xe0\x00\x00\x30\xe1\x00\x00\xec\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\xe2\x00\x00\x26\xe3\x00\x00\x26\xe4\x00\x00\x1c\xe5\x00\x00\x1c\xe6\x00\x00\x12\xe7\x00\x00\x12\xe8\x00\x00\x12\xe9\x00\x00\x12\xea\x00\x00\x12\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x12\x00\x00\xa3\x13\x00\x00\x99\x14\x00\x00\x8f\x15\x00\x00\x7b\x17\x00\x00\x71\x18\x00\x00\x67\x19\x00\x00\x5d\x1a\x00\x00\x53\x1b\x00\x00\x35\x1e\x00\x00\x2f\x20\x00\x00\x26\x21\x00\x00\x1d\x22\x00\x00\x14\x23\x00\x00\xf9\x25\x00\x00\xf0\x26\x00\x00\xe7\x27\x00\x00\xde\x28\x00\x00\xd5\x29\x00\x00\xcc\x2a\x00\x00\xc3\x2b\x00\x00\xba\x2c\x00\x00\xb1\x2d\x00\x00\x9f\x2f\x00\x00\x96\x30\x00\x00\x8d\x31\x00\x00\x84\x32\x00\x00\x7b\x33\x00\x00\x72\x34\x00\x00\x69\x35\x00\x00\x60\x36\x00\x00\x57\x37\x00\x00\x4e\x38\x00\x00\x45\x39\x00\x00\x3c\x3a\x00\x00\x33\x3b\x00\x00\x34\x3c\x00\x00\x21\x3d\x00\x00\x22\x3e\x00\x00\x10\x40\x00\x00\x38\x57\x00\x00\x14\x5b\x00\x00\xf9\x5d\x00\x00\x3c\x72\x00\x00\xf4\x79\x00\x00\xd0\x7d\x00\x00\xbe\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\xff\xff\xff\xe3\xff\xff\xff\x00\x00\x00\x00\x9a\x83\x00\x00\x76\x87\x00\x00\x56\x52\x00\x00\x2e\x8f\x00\x00\xb9\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\xa3\x00\x00\x85\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\xe2\x00\x00\x06\xe5\x00\x00\xf1\xeb\x00\x00\x4d\xec\x00\x00\xa9\xec\x00\x00\x05\xed\x00\x00\x61\xed\x00\x00\xbd\xed\x00\x00\x19\xee\x00\x00\x75\xee\x00\x00\xd1\xee\x00\x00\x2d\xef\x00\x00\x89\xef\x00\x00\xe5\xef\x00\x00\x41\xf0\x00\x00\x9d\xf0\x00\x00\xf9\xf0\x00\x00\x55\xf1\x00\x00\xb1\xf1\x00\x00\x0d\xf2\x00\x00\x6b\xf2\x00\x00\xc9\xf2\x00\x00\x27\xf3\x00\x00\x85\xf3\x00\x00\xe3\xf3\x00\x00\x41\xf4\x00\x00\x9f\xf4\x00\x00\xfb\xf4\x00\x00\x57\xf5\x00\x00\xb3\xf5\x00\x00\x0f\xf6\x00\x00\x6b\xf6\x00\x00\xc7\xf6\x00\x00\x23\xf7\x00\x00\x7f\xf7\x00\x00\xdb\xf7\x00\x00\x37\xf8\x00\x00\x93\xf8\x00\x00\xef\xf8\x00\x00\x4b\xf9\x00\x00\xa7\xf9\x00\x00\x03\xfa\x00\x00\x5f\xfa\x00\x00\xbb\xfa\x00\x00\x17\xfb\x00\x00\x73\xfb\x00\x00\xcf\xfb\x00\x00\x2b\xfc\x00\x00\x87\xfc\x00\x00\xe3\xfc\x00\x00\x3f\xfd\x00\x00\x9b\xfd\x00\x00\xf7\xfd\x00\x00\x53\xfe\x00\x00\xaf\xfe\x00\x00\x0b\xff\x00\x00\x67\xff\x00\x00\xc3\xff\x00\x00\x1f\x00\x01\x00\x7b\x00\x01\x00\xd7\x00\x01\x00\x33\x01\x01\x00\x8f\x01\x01\x00\xeb\x01\x01\x00\x47\x02\x01\x00\xa3\x02\x01\x00\xff\x02\x01\x00\x5b\x03\x01\x00\xb7\x03\x01\x00\x13\x04\x01\x00\x6f\x04\x01\x00\xcb\x04\x01\x00\x27\x05\x01\x00\x83\x05\x01\x00\xdf\x05\x01\x00\x3b\x06\x01\x00\x97\x06\x01\x00\xf3\x06\x01\x00\x4f\x07\x01\x00\xab\x07\x01\x00\x07\x08\x01\x00\x63\x08\x01\x00\xbf\x08\x01\x00\x1b\x09\x01\x00\x77\x09\x01\x00\xd3\x09\x01\x00\x2f\x0a\x01\x00\x8b\x0a\x01\x00\xe7\x0a\x01\x00\x43\x0b\x01\x00\x9f\x0b\x01\x00\xfb\x0b\x01\x00\x57\x0c\x01\x00\xb3\x0c\x01\x00\x0f\x0d\x01\x00\x6b\x0d\x01\x00\xc7\x0d\x01\x00\x23\x0e\x01\x00\x7f\x0e\x01\x00\xdb\x0e\x01\x00\x37\x0f\x01\x00\x93\x0f\x01\x00\xef\x0f\x01\x00\x4b\x10\x01\x00\xa7\x10\x01\x00\x03\x11\x01\x00\x5f\x11\x01\x00\xbb\x11\x01\x00\x17\x12\x01\x00\x73\x12\x01\x00\xcf\x12\x01\x00\x2b\x13\x01\x00\x87\x13\x01\x00\xe3\x13\x01\x00\x3f\x14\x01\x00\x9b\x14\x01\x00\xf7\x14\x01\x00\x53\x15\x01\x00\xaf\x15\x01\x00\x0b\x16\x01\x00\x67\x16\x01\x00\xc3\x16\x01\x00\x1f\x17\x01\x00\x7b\x17\x01\x00\xd7\x17\x01\x00\x33\x18\x01\x00\x8f\x18\x01\x00\xeb\x18\x01\x00\x47\x19\x01\x00\xa3\x19\x01\x00\xff\x19\x01\x00\x5b\x1a\x01\x00\xb7\x1a\x01\x00\x13\x1b\x01\x00\x6f\x1b\x01\x00\xcb\x1b\x01\x00\x27\x1c\x01\x00\x83\x1c\x01\x00\xdf\x1c\x01\x00\x3b\x1d\x01\x00\x97\x1d\x01\x00\xf3\x1d\x01\x00\x4f\x1e\x01\x00\xab\x1e\x01\x00\x07\x1f\x01\x00\x63\x1f\x01\x00\xbf\x1f\x01\x00\x1b\x20\x01\x00\x77\x20\x01\x00\xd3\x20\x01\x00\x2f\x21\x01\x00\x8b\x21\x01\x00\xe7\x21\x01\x00\x43\x22\x01\x00\x9f\x22\x01\x00\xfb\x22\x01\x00\x57\x23\x01\x00\xb3\x23\x01\x00\x0f\x24\x01\x00\x6b\x24\x01\x00\xc7\x24\x01\x00\x23\x25\x01\x00\x7f\x25\x01\x00\xdb\x25\x01\x00\x37\x26\x01\x00\x93\x26\x01\x00\xef\x26\x01\x00\x4b\x27\x01\x00\xa7\x27\x01\x00\x03\x28\x01\x00\x5f\x28\x01\x00\xbb\x28\x01\x00\x17\x29\x01\x00\x73\x29\x01\x00\xcf\x29\x01\x00\x2b\x2a\x01\x00\x87\x2a\x01\x00\xe3\x2a\x01\x00\x3f\x2b\x01\x00\x9b\x2b\x01\x00\xf7\x2b\x01\x00\x53\x2c\x01\x00\xaf\x2c\x01\x00\x0b\x2d\x01\x00\x67\x2d\x01\x00\xc3\x2d\x01\x00\x1f\x2e\x01\x00\x7b\x2e\x01\x00\xd7\x2e\x01\x00\x33\x2f\x01\x00\x8f\x2f\x01\x00\xeb\x2f\x01\x00\x47\x30\x01\x00\xa3\x30\x01\x00\xff\x30\x01\x00\x5b\x31\x01\x00\xb7\x31\x01\x00\x13\x32\x01\x00\x6f\x32\x01\x00\xcb\x32\x01\x00\x27\x33\x01\x00\x83\x33\x01\x00\xdf\x33\x01\x00\x3b\x34\x01\x00\x97\x34\x01\x00\xf3\x34\x01\x00\x4f\x35\x01\x00\xab\x35\x01\x00\x07\x36\x01\x00\x63\x36\x01\x00\xbf\x36\x01\x00\x1b\x37\x01\x00\x77\x37\x01\x00\xd3\x37\x01\x00\x2f\x38\x01\x00\x8b\x38\x01\x00\xe7\x38\x01\x00\x43\x39\x01\x00\x9f\x39\x01\x00\xfb\x39\x01\x00\x57\x3a\x01\x00\xb3\x3a\x01\x00\x0f\x3b\x01\x00\x6b\x3b\x01\x00\xc7\x3b\x01\x00\x23\x3c\x01\x00\x7f\x3c\x01\x00"#
+alex_base = AlexA# "\xf7\xff\xff\xff\x6c\x00\x00\x00\xe1\x00\x00\x00\x55\x01\x00\x00\xca\x01\x00\x00\x3f\x02\x00\x00\xb5\x02\x00\x00\x73\x00\x00\x00\xd8\xff\xff\xff\x94\x03\x00\x00\xf2\x03\x00\x00\x50\x04\x00\x00\xb6\x02\x00\x00\xac\x04\x00\x00\x08\x05\x00\x00\x5d\x05\x00\x00\x5c\x05\x00\x00\xdc\x05\x00\x00\xbb\x06\x00\x00\xba\x06\x00\x00\x3a\x07\x00\x00\xba\x07\x00\x00\x99\x08\x00\x00\xf5\x08\x00\x00\xf4\x08\x00\x00\x00\x00\x00\x00\x65\x09\x00\x00\x00\x00\x00\x00\xd6\x09\x00\x00\x00\x00\x00\x00\x47\x0a\x00\x00\x00\x00\x00\x00\x88\x0a\x00\x00\x00\x00\x00\x00\xc9\x0a\x00\x00\x00\x00\x00\x00\x0a\x0b\x00\x00\xe9\x0b\x00\x00\x68\x0c\x00\x00\x28\x0c\x00\x00\x00\x00\x00\x00\x28\x0d\x00\x00\xe8\x0c\x00\x00\x00\x00\x00\x00\xe8\x0d\x00\x00\x5e\x0e\x00\x00\xc0\x0d\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x0f\x00\x00\x4c\x10\x00\x00\x43\x11\x00\x00\x3a\x12\x00\x00\x31\x13\x00\x00\x28\x14\x00\x00\x1f\x15\x00\x00\x16\x16\x00\x00\x0d\x17\x00\x00\x04\x18\x00\x00\xfb\x18\x00\x00\xf2\x19\x00\x00\xe9\x1a\x00\x00\xe0\x1b\x00\x00\xd7\x1c\x00\x00\xce\x1d\x00\x00\xc5\x1e\x00\x00\xbc\x1f\x00\x00\xb3\x20\x00\x00\xaa\x21\x00\x00\xa1\x22\x00\x00\x98\x23\x00\x00\x8f\x24\x00\x00\x86\x25\x00\x00\x7d\x26\x00\x00\x74\x27\x00\x00\x6b\x28\x00\x00\x62\x29\x00\x00\x59\x2a\x00\x00\x50\x2b\x00\x00\x47\x2c\x00\x00\x3e\x2d\x00\x00\x35\x2e\x00\x00\x2c\x2f\x00\x00\x23\x30\x00\x00\x1a\x31\x00\x00\x11\x32\x00\x00\x08\x33\x00\x00\xff\x33\x00\x00\xf6\x34\x00\x00\xed\x35\x00\x00\xe4\x36\x00\x00\xdb\x37\x00\x00\xd2\x38\x00\x00\xc9\x39\x00\x00\xc0\x3a\x00\x00\xb7\x3b\x00\x00\xae\x3c\x00\x00\xa5\x3d\x00\x00\x9c\x3e\x00\x00\x93\x3f\x00\x00\x8a\x40\x00\x00\x81\x41\x00\x00\x78\x42\x00\x00\x6f\x43\x00\x00\x66\x44\x00\x00\x5d\x45\x00\x00\x54\x46\x00\x00\x4b\x47\x00\x00\x42\x48\x00\x00\x39\x49\x00\x00\x30\x4a\x00\x00\x27\x4b\x00\x00\x1e\x4c\x00\x00\x15\x4d\x00\x00\x0c\x4e\x00\x00\x03\x4f\x00\x00\xfa\x4f\x00\x00\xf1\x50\x00\x00\xe8\x51\x00\x00\xdf\x52\x00\x00\xd6\x53\x00\x00\xcd\x54\x00\x00\xc4\x55\x00\x00\xbb\x56\x00\x00\xb2\x57\x00\x00\xa9\x58\x00\x00\xa0\x59\x00\x00\x97\x5a\x00\x00\x8e\x5b\x00\x00\x85\x5c\x00\x00\x7c\x5d\x00\x00\x73\x5e\x00\x00\x6a\x5f\x00\x00\x61\x60\x00\x00\x58\x61\x00\x00\x4f\x62\x00\x00\x46\x63\x00\x00\x3d\x64\x00\x00\x34\x65\x00\x00\x2b\x66\x00\x00\x22\x67\x00\x00\x19\x68\x00\x00\x10\x69\x00\x00\x07\x6a\x00\x00\xfe\x6a\x00\x00\xf5\x6b\x00\x00\xec\x6c\x00\x00\xe3\x6d\x00\x00\xda\x6e\x00\x00\xd1\x6f\x00\x00\xc8\x70\x00\x00\xbf\x71\x00\x00\xb6\x72\x00\x00\xad\x73\x00\x00\xa4\x74\x00\x00\x9b\x75\x00\x00\x92\x76\x00\x00\x89\x77\x00\x00\x80\x78\x00\x00\x77\x79\x00\x00\x6e\x7a\x00\x00\x65\x7b\x00\x00\x5c\x7c\x00\x00\x53\x7d\x00\x00\x4a\x7e\x00\x00\x41\x7f\x00\x00\x38\x80\x00\x00\x2f\x81\x00\x00\x26\x82\x00\x00\x1d\x83\x00\x00\x14\x84\x00\x00\x0b\x85\x00\x00\x02\x86\x00\x00\xf9\x86\x00\x00\xf0\x87\x00\x00\xe7\x88\x00\x00\xde\x89\x00\x00\xd5\x8a\x00\x00\xcc\x8b\x00\x00\xc3\x8c\x00\x00\xba\x8d\x00\x00\xb1\x8e\x00\x00\xa8\x8f\x00\x00\x9f\x90\x00\x00\x96\x91\x00\x00\x8d\x92\x00\x00\x84\x93\x00\x00\x7b\x94\x00\x00\x72\x95\x00\x00\x69\x96\x00\x00\x60\x97\x00\x00\x57\x98\x00\x00\x4e\x99\x00\x00\x45\x9a\x00\x00\x3c\x9b\x00\x00\x33\x9c\x00\x00\x2a\x9d\x00\x00\x21\x9e\x00\x00\x18\x9f\x00\x00\x0f\xa0\x00\x00\x06\xa1\x00\x00\xfd\xa1\x00\x00\xf4\xa2\x00\x00\xeb\xa3\x00\x00\xe2\xa4\x00\x00\xd9\xa5\x00\x00\xd0\xa6\x00\x00\xc7\xa7\x00\x00\xbe\xa8\x00\x00\xb5\xa9\x00\x00\xac\xaa\x00\x00\xa3\xab\x00\x00\x9a\xac\x00\x00\x91\xad\x00\x00\x88\xae\x00\x00\x7f\xaf\x00\x00\x76\xb0\x00\x00\x6d\xb1\x00\x00\x64\xb2\x00\x00\x5b\xb3\x00\x00\x52\xb4\x00\x00\x49\xb5\x00\x00\x40\xb6\x00\x00\x37\xb7\x00\x00\x2e\xb8\x00\x00\x25\xb9\x00\x00\x1c\xba\x00\x00\x13\xbb\x00\x00\x0a\xbc\x00\x00\x01\xbd\x00\x00\xf8\xbd\x00\x00\xef\xbe\x00\x00\xe6\xbf\x00\x00\xdd\xc0\x00\x00\xd4\xc1\x00\x00\xcb\xc2\x00\x00\xc2\xc3\x00\x00\xb9\xc4\x00\x00\xb0\xc5\x00\x00\xa7\xc6\x00\x00\x9e\xc7\x00\x00\x95\xc8\x00\x00\x8c\xc9\x00\x00\x83\xca\x00\x00\x7a\xcb\x00\x00\x71\xcc\x00\x00\x68\xcd\x00\x00\x5f\xce\x00\x00\x56\xcf\x00\x00\x4d\xd0\x00\x00\xe3\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\xd1\x00\x00\x43\xd2\x00\x00\x43\xd3\x00\x00\x39\xd4\x00\x00\x39\xd5\x00\x00\x2f\xd6\x00\x00\x2f\xd7\x00\x00\x2f\xd8\x00\x00\x2f\xd9\x00\x00\x2f\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x0f\x00\x00\x43\x10\x00\x00\x3a\x11\x00\x00\x31\x12\x00\x00\x16\x15\x00\x00\x0d\x16\x00\x00\x04\x17\x00\x00\xfb\x17\x00\x00\xf2\x18\x00\x00\xe9\x19\x00\x00\xe0\x1a\x00\x00\xd7\x1b\x00\x00\xce\x1c\x00\x00\xbc\x1e\x00\x00\xb3\x1f\x00\x00\xaa\x20\x00\x00\xa1\x21\x00\x00\x98\x22\x00\x00\x8f\x23\x00\x00\x86\x24\x00\x00\x7d\x25\x00\x00\x74\x26\x00\x00\x6b\x27\x00\x00\x62\x28\x00\x00\x59\x29\x00\x00\x50\x2a\x00\x00\x51\x2b\x00\x00\x3e\x2c\x00\x00\x3f\x2d\x00\x00\x2d\x2f\x00\x00\x55\x46\x00\x00\x31\x4a\x00\x00\x16\x4d\x00\x00\x59\x61\x00\x00\x11\x69\x00\x00\xf6\x6b\x00\x00\xed\x6c\x00\x00\xdb\x6e\x00\x00\xb7\x72\x00\x00\x54\x7d\x00\x00\xfa\x86\x00\x00\x9f\x8f\x00\x00\x2d\xd1\x00\x00\x23\xd4\x00\x00\x0e\xdb\x00\x00\x6a\xdb\x00\x00\xc6\xdb\x00\x00\x22\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xff\xff\xff\xda\xff\xff\xff\x00\x00\x00\x00\x7e\xdc\x00\x00\xda\xdc\x00\x00\x73\x41\x00\x00\x36\xdd\x00\x00\x92\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\xff\xff\xff\x00\x00\x00\x00\xee\xdd\x00\x00\x23\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\xde\x00\x00\xa6\xde\x00\x00\x02\xdf\x00\x00\x5e\xdf\x00\x00\xba\xdf\x00\x00\x16\xe0\x00\x00\x72\xe0\x00\x00\xce\xe0\x00\x00\x2a\xe1\x00\x00\x86\xe1\x00\x00\xe2\xe1\x00\x00\x3e\xe2\x00\x00\x9a\xe2\x00\x00\xf6\xe2\x00\x00\x52\xe3\x00\x00\xae\xe3\x00\x00\x0a\xe4\x00\x00\x66\xe4\x00\x00\xc2\xe4\x00\x00\x1e\xe5\x00\x00\x7c\xe5\x00\x00\xda\xe5\x00\x00\x38\xe6\x00\x00\x96\xe6\x00\x00\xf4\xe6\x00\x00\x52\xe7\x00\x00\xb0\xe7\x00\x00\x0c\xe8\x00\x00\x68\xe8\x00\x00\xc4\xe8\x00\x00\x20\xe9\x00\x00\x7c\xe9\x00\x00\xd8\xe9\x00\x00\x34\xea\x00\x00\x90\xea\x00\x00\xec\xea\x00\x00\x48\xeb\x00\x00\xa4\xeb\x00\x00\x00\xec\x00\x00\x5c\xec\x00\x00\xb8\xec\x00\x00\x14\xed\x00\x00\x70\xed\x00\x00\xcc\xed\x00\x00\x28\xee\x00\x00\x84\xee\x00\x00\xe0\xee\x00\x00\x3c\xef\x00\x00\x98\xef\x00\x00\xf4\xef\x00\x00\x50\xf0\x00\x00\xac\xf0\x00\x00\x08\xf1\x00\x00\x64\xf1\x00\x00\xc0\xf1\x00\x00\x1c\xf2\x00\x00\x78\xf2\x00\x00\xd4\xf2\x00\x00\x30\xf3\x00\x00\x8c\xf3\x00\x00\xe8\xf3\x00\x00\x44\xf4\x00\x00\xa0\xf4\x00\x00\xfc\xf4\x00\x00\x58\xf5\x00\x00\xb4\xf5\x00\x00\x10\xf6\x00\x00\x6c\xf6\x00\x00\xc8\xf6\x00\x00\x24\xf7\x00\x00\x80\xf7\x00\x00\xdc\xf7\x00\x00\x38\xf8\x00\x00\x94\xf8\x00\x00\xf0\xf8\x00\x00\x4c\xf9\x00\x00\xa8\xf9\x00\x00\x04\xfa\x00\x00\x60\xfa\x00\x00\xbc\xfa\x00\x00\x18\xfb\x00\x00\x74\xfb\x00\x00\xd0\xfb\x00\x00\x2c\xfc\x00\x00\x88\xfc\x00\x00\xe4\xfc\x00\x00\x40\xfd\x00\x00\x9c\xfd\x00\x00\xf8\xfd\x00\x00\x54\xfe\x00\x00\xb0\xfe\x00\x00\x0c\xff\x00\x00\x68\xff\x00\x00\xc4\xff\x00\x00\x20\x00\x01\x00\x7c\x00\x01\x00\xd8\x00\x01\x00\x34\x01\x01\x00\x90\x01\x01\x00\xec\x01\x01\x00\x48\x02\x01\x00\xa4\x02\x01\x00\x00\x03\x01\x00\x5c\x03\x01\x00\xb8\x03\x01\x00\x14\x04\x01\x00\x70\x04\x01\x00\xcc\x04\x01\x00\x28\x05\x01\x00\x84\x05\x01\x00\xe0\x05\x01\x00\x3c\x06\x01\x00\x98\x06\x01\x00\xf4\x06\x01\x00\x50\x07\x01\x00\xac\x07\x01\x00\x08\x08\x01\x00\x64\x08\x01\x00\xc0\x08\x01\x00\x1c\x09\x01\x00\x78\x09\x01\x00\xd4\x09\x01\x00\x30\x0a\x01\x00\x8c\x0a\x01\x00\xe8\x0a\x01\x00\x44\x0b\x01\x00\xa0\x0b\x01\x00\xfc\x0b\x01\x00\x58\x0c\x01\x00\xb4\x0c\x01\x00\x10\x0d\x01\x00\x6c\x0d\x01\x00\xc8\x0d\x01\x00\x24\x0e\x01\x00\x80\x0e\x01\x00\xdc\x0e\x01\x00\x38\x0f\x01\x00\x94\x0f\x01\x00\xf0\x0f\x01\x00\x4c\x10\x01\x00\xa8\x10\x01\x00\x04\x11\x01\x00\x60\x11\x01\x00\xbc\x11\x01\x00\x18\x12\x01\x00\x74\x12\x01\x00\xd0\x12\x01\x00\x2c\x13\x01\x00\x88\x13\x01\x00\xe4\x13\x01\x00\x40\x14\x01\x00\x9c\x14\x01\x00\xf8\x14\x01\x00\x54\x15\x01\x00\xb0\x15\x01\x00\x0c\x16\x01\x00\x68\x16\x01\x00\xc4\x16\x01\x00\x20\x17\x01\x00\x7c\x17\x01\x00\xd8\x17\x01\x00\x34\x18\x01\x00\x90\x18\x01\x00\xec\x18\x01\x00\x48\x19\x01\x00\xa4\x19\x01\x00\x00\x1a\x01\x00\x5c\x1a\x01\x00\xb8\x1a\x01\x00\x14\x1b\x01\x00\x70\x1b\x01\x00\xcc\x1b\x01\x00\x28\x1c\x01\x00\x84\x1c\x01\x00\xe0\x1c\x01\x00\x3c\x1d\x01\x00\x98\x1d\x01\x00\xf4\x1d\x01\x00\x50\x1e\x01\x00\xac\x1e\x01\x00\x08\x1f\x01\x00\x64\x1f\x01\x00\xc0\x1f\x01\x00\x1c\x20\x01\x00\x78\x20\x01\x00\xd4\x20\x01\x00\x30\x21\x01\x00\x8c\x21\x01\x00\xe8\x21\x01\x00\x44\x22\x01\x00\xa0\x22\x01\x00\xfc\x22\x01\x00\x58\x23\x01\x00\xb4\x23\x01\x00\x10\x24\x01\x00\x6c\x24\x01\x00\xc8\x24\x01\x00\x24\x25\x01\x00\x80\x25\x01\x00\xdc\x25\x01\x00\x38\x26\x01\x00\x94\x26\x01\x00\xf0\x26\x01\x00\x4c\x27\x01\x00\xa8\x27\x01\x00\x04\x28\x01\x00\x60\x28\x01\x00\xbc\x28\x01\x00\x18\x29\x01\x00\x74\x29\x01\x00\xd0\x29\x01\x00\x2c\x2a\x01\x00\x88\x2a\x01\x00\xe4\x2a\x01\x00\x40\x2b\x01\x00\x9c\x2b\x01\x00\xf8\x2b\x01\x00\x54\x2c\x01\x00\xb0\x2c\x01\x00\x0c\x2d\x01\x00\x68\x2d\x01\x00\xc4\x2d\x01\x00\x20\x2e\x01\x00\x7c\x2e\x01\x00\xd8\x2e\x01\x00\x34\x2f\x01\x00\x90\x2f\x01\x00\xec\x2f\x01\x00\x48\x30\x01\x00\xa4\x30\x01\x00\x00\x31\x01\x00\x5c\x31\x01\x00"#
alex_table :: AlexAddr
-alex_table = AlexA# "\x00\x00\x2e\x01\x54\x00\x54\x00\x54\x00\x53\x00\x21\x01\x08\x00\x27\x00\x1e\x00\x1f\x00\x22\x00\x20\x00\x13\x00\x43\x00\x56\x00\x61\x01\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\xf9\x01\x73\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x72\x01\x6a\x01\x6b\x01\xf9\x01\xf9\x01\xf9\x01\x88\x01\x63\x01\xf9\x01\x7a\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x65\x01\x64\x01\xf9\x01\x66\x01\xf9\x01\x68\x01\x6e\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xac\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x6d\x01\xf9\x01\xf9\x01\x67\x01\xf9\x01\xfd\x01\xf9\x01\xdb\x01\xba\x01\xfb\x01\xcf\x01\xf9\x01\xe6\x01\x55\x02\xf9\x01\xf9\x01\xa5\x01\xd3\x01\xf8\x01\x1e\x02\xe8\x01\xd4\x01\xdc\x01\xe5\x01\xe4\x01\xd7\x01\xf9\x01\xb4\x01\xf9\x01\xf9\x01\xf9\x01\x70\x01\x69\x01\x71\x01\xf9\x01\x2f\x01\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x54\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x0a\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x1b\x00\x15\x00\x15\x00\x1a\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x09\x00\x15\x00\x00\x00\x15\x00\x2e\x01\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\xf9\x01\x73\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x72\x01\x6a\x01\x6b\x01\xf9\x01\xf9\x01\xf9\x01\x88\x01\x63\x01\xf9\x01\x7a\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x78\x01\x65\x01\x64\x01\xf9\x01\x66\x01\xf9\x01\x68\x01\x6e\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xac\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x6d\x01\xf9\x01\xf9\x01\x67\x01\xf9\x01\xfd\x01\xf9\x01\xdb\x01\xba\x01\xfb\x01\xcf\x01\xf9\x01\xe6\x01\x55\x02\xf9\x01\xf9\x01\xa5\x01\xd3\x01\xf8\x01\x1e\x02\xe8\x01\xd4\x01\xdc\x01\xe5\x01\xe4\x01\xd7\x01\xf9\x01\xb4\x01\xf9\x01\xf9\x01\xf9\x01\x70\x01\x69\x01\x71\x01\xf9\x01\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x0a\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x1c\x00\x15\x00\x15\x00\x1a\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x09\x00\x15\x00\x00\x00\x15\x00\x2e\x01\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\xf9\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\x00\x00\x00\x00\xf9\x01\xf9\x01\xf9\x01\x87\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x0d\x00\xf9\x01\xf9\x01\x0c\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xa3\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x09\x00\xf9\x01\x00\x00\xf9\x01\x30\x01\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x0a\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x1b\x00\x15\x00\x15\x00\x1a\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x09\x00\x15\x00\x00\x00\x15\x00\xff\xff\x55\x00\x55\x00\x55\x00\x55\x00\x60\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\xf9\x01\x8c\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xbb\x00\xc5\x00\xbf\x00\x00\x00\x00\x00\x00\x00\xbe\x00\xb2\x00\x00\x00\x00\x00\x9e\x00\xc0\x00\xd3\x00\xed\x00\x00\x00\x00\x00\xc4\x00\xf0\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xf9\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\xf9\x01\x00\x00\xf9\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x39\x00\x14\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2f\x00\x19\x00\x25\x00\x25\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x4e\x00\x4e\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x02\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x4e\x00\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x02\x00\x00\x39\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3c\x00\x12\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x31\x00\x18\x00\x28\x00\x28\x00\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x25\x01\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x22\x01\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x0b\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x23\x01\x15\x00\xf9\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\xf9\x01\x00\x00\xf9\x01\x39\x02\xf9\x01\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x00\x00\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x0f\x00\x39\x02\x39\x02\x0e\x00\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x39\x02\x00\x00\x39\x02\x00\x00\x39\x02\x3e\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x3b\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x3d\x00\x38\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x0b\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x00\x00\x15\x00\x35\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x11\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x12\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x30\x00\x14\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x2e\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x00\x15\x00\x15\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x15\x00\x16\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf