.github/ISSUE_TEMPLATE.mdnew file+9
@@ -0,0 +1,9 @@
1+Please attach complete source files that exhibit the issue in addition
2+to quoting from them here.
@@ -1,30 +1,55 @@
2−cabal-dev/
3+dist-newstyle
11−*.swp
10+src/Version_idris.hs
13−.DS_Store
12+# Doc generation artefacts
14−.hpc
13+libs/base/base_doc/
15−*.tix
14+libs/effects/effects_doc/
16−custom.mk
15+libs/prelude/prelude_doc/
16+libs/contrib/contrib_doc/
17+libs/pruviloj/pruviloj_doc/
18+libs/oldeffects/oldeffects_doc/
17test/output
21test/output
18test/*[0-9][0-9][0-9]/output
22test/*[0-9][0-9][0-9]/output
19test/*[0-9][0-9][0-9]/*.exe
23test/*[0-9][0-9][0-9]/*.exe
20−tutorial/*.aux
24+test/runtest.exe
21−tutorial/*.bbl
25+test/runtest
22−tutorial/*.blg
26+.tasty-rerun-log
24−tutorial/*.out
28+# Haskell build tools
25−tutorial/*.toc
29+cabal-dev/
26−tutorial/*.fdb_latexmk
30+.cabal-sandbox
27−tutorial/*.fls
31+cabal.sandbox.config
30−src/Version_idris.hs
42+
@@ -0,0 +1,61 @@
1+# HLint configuration file
2+# https://github.com/ndmitchell/hlint
3+##########################
5+# This file contains a template configuration file, which is typically
6+# placed as .hlint.yaml in the root of your project
9+# Specify additional command line arguments
11+# - arguments: [--color, --cpp-simple, -XQuasiQuotes]
14+# Control which extensions/flags/modules/functions can be used
17+# - default: false # all extension are banned by default
18+# - name: [PatternGuards, ViewPatterns] # only these listed extensions can be used
19+# - {name: CPP, within: CrossPlatform} # CPP can only be used in a given module
22+# - {name: -w, within: []} # -w is allowed nowhere
25+# - {name: [Data.Set, Data.HashSet], as: Set} # if you import Data.Set qualified, it must be as 'Set'
26+# - {name: Control.Arrow, within: []} # Certain modules are banned entirely
29+# - {name: unsafePerformIO, within: []} # unsafePerformIO can only appear in no modules
32+# Add custom hints for this project
34+# Will suggest replacing "wibbleMany [myvar]" with "wibbleOne myvar"
35+# - error: {lhs: "wibbleMany [x]", rhs: wibbleOne x}
38+# Turn on hints that are off by default
40+# Ban "module X(module X) where", to require a real export list
41+# - warn: {name: Use explicit module export list}
43+# Replace a $ b $ c with a . b $ c
44+# - group: {name: dollar, enabled: true}
46+# Generalise map to fmap, ++ to <>
47+# - group: {name: generalise, enabled: true}
50+# Ignore some builtin hints
51+# - ignore: {name: Use let}
52+# - ignore: {name: Use const, within: SpecialModule} # Only within certain modules
53+- ignore: {name: Use camelCase}
54+- ignore: {name: Reduce duplication}
56+# Define some custom infix operators
57+# - fixity: infixr 3 ~^#^~
60+# To generate a suitable file for HLint do:
61+# $ hlint --default > .hlint.yaml
.stylish-haskell.yamlnew file+154
@@ -0,0 +1,154 @@
1+# stylish-haskell configuration file
2+# ==================================
4+# The stylish-haskell tool is mainly configured by specifying steps. These steps
5+# are a list, so they have an order, and one specific step may appear more than
6+# once (if needed). Each file is processed by these steps in the given order.
8+ # Convert some ASCII sequences to their Unicode equivalents. This is disabled
11+ # # In order to make this work, we also need to insert the UnicodeSyntax
12+ # # language pragma. If this flag is set to true, we insert it when it's
13+ # # not already present. You may want to disable it if you configure
14+ # # language extensions using some other method than pragmas. Default:
16+ # add_language_pragma: true
20+ # There are different ways we can align names and lists.
22+ # - global: Align the import names and import list throughout the entire
25+ # - file: Like global, but don't add padding when there are no qualified
26+ # imports in the file.
28+ # - group: Only align the imports per group (a group is formed by adjacent
31+ # - none: Do not perform any alignment.
36+ # Folowing options affect only import list alignment.
38+ # List align has following options:
40+ # - after_alias: Import list is aligned with end of import including
41+ # 'as' and 'hiding' keywords.
43+ # > import qualified Data.List as List (concat, foldl, foldr, head,
44+ # > init, last, length)
46+ # - with_alias: Import list is aligned with start of alias or hiding.
48+ # > import qualified Data.List as List (concat, foldl, foldr, head,
49+ # > init, last, length)
51+ # - new_line: Import list starts always on new line.
53+ # > import qualified Data.List as List
54+ # > (concat, foldl, foldr, head, init, last, length)
56+ # Default: after_alias
57+ list_align: after_alias
59+ # Long list align style takes effect when import is too long. This is
60+ # determined by 'columns' setting.
62+ # - inline: This option will put as much specs on same line as possible.
64+ # - new_line: Import list will start on new line.
66+ # - new_line_multiline: Import list will start on new line when it's
67+ # short enough to fit to single line. Otherwise it'll be multiline.
69+ # - multiline: One line per import list entry.
70+ # Type with contructor list acts like single import.
72+ # > import qualified Data.Map as M
80+ long_list_align: inline
82+ # List padding determines indentation of import list on lines after import.
83+ # This option affects 'list_align' and 'long_list_align'.
86+ # Separate lists option affects formating of import list for type
87+ # or class. The only difference is single space between type and list
88+ # of constructors, selectors and class functions.
90+ # - true: There is single space between Foldable type and list of it's
93+ # > import Data.Foldable (Foldable (fold, foldl, foldMap))
95+ # - false: There is no space between Foldable type and list of it's
98+ # > import Data.Foldable (Foldable(fold, foldl, foldMap))
101+ separate_lists: false
105+ # We can generate different styles of language pragma lists.
107+ # - vertical: Vertical-spaced language pragmas, one per line.
109+ # - compact: A more compact style.
111+ # - compact_line: Similar to compact, but wrap each line with
112+ # `{-#LANGUAGE #-}'.
114+ # Default: vertical.
117+ # Align affects alignment of closing pragma brackets.
119+ # - true: Brackets are aligned in same collumn.
121+ # - false: Brackets are not aligned together. There is only one space
122+ # between actual import and closing bracket.
127+ # stylish-haskell can detect redundancy of some language pragmas. If this
128+ # is set to true, it will remove those redundant pragmas. Default: true.
129+ remove_redundant: true
131+ # Align the types in record declarations
134+ # Replace tabs by spaces. This is disabled by default.
136+ # # Number of spaces to use for each tab. Default: 8, as specified by the
140+ # Remove trailing whitespace
141+ - trailing_whitespace: {}
143+# A common setting is the number of columns (parts of) code will be wrapped
144+# to. Different steps take this into account. Default: 80.
147+# Sometimes, language extensions are specified in a cabal file or from the
148+# command line instead of using language pragmas in the file. stylish-haskell
149+# needs to be aware of these, so it can parse the file correctly.
151+# No language extensions are enabled by default.
152+# language_extensions:
@@ -1,26 +1,176 @@
1−language: haskell
3+language: c
11+ - env: CABALVER="2.4" GHCVER="8.6.5" STACKVER="15.4" STYLISH=YES
12+ addons: {apt: {packages: [cabal-install-2.4,ghc-8.6.5,hscolour], sources: [hvr-ghc]}}
13+ - env: CABALVER="2.4" GHCVER="8.2.2" TESTS="lib_doc doc"
14+ compiler: ": #GHC 8.2.2"
15+ addons: {apt: {packages: [cabal-install-2.4,ghc-8.2.2,cppcheck,hscolour], sources: [hvr-ghc]}}
16+ - env: CABALVER="2.4" GHCVER="8.2.2" TESTS="test_js"
17+ compiler: ": #GHC 8.2.2"
18+ addons: {apt: {packages: [cabal-install-2.4,ghc-8.2.2,cppcheck,hscolour], sources: [hvr-ghc]}}
19+ - env: CABALVER="2.4" GHCVER="8.2.2" TESTS="test_c"
20+ compiler: ": #GHC 8.2.2"
21+ addons: {apt: {packages: [cabal-install-2.4,ghc-8.2.2,cppcheck,hscolour], sources: [hvr-ghc]}}
22+ - env: CABALVER="2.4" GHCVER="8.4.4" TESTS="lib_doc doc"
23+ compiler: ": #GHC 8.4.4"
24+ addons: {apt: {packages: [cabal-install-2.4,ghc-8.4.4,cppcheck,hscolour], sources: [hvr-ghc]}}
25+ - env: CABALVER="2.4" GHCVER="8.4.4" TESTS="test_js"
26+ compiler: ": #GHC 8.4.4"
27+ addons: {apt: {packages: [cabal-install-2.4,ghc-8.4.4,cppcheck,hscolour], sources: [hvr-ghc]}}
28+ - env: CABALVER="2.4" GHCVER="8.4.4" TESTS="test_c"
29+ compiler: ": #GHC 8.4.4"
30+ addons: {apt: {packages: [cabal-install-2.4,ghc-8.4.4,cppcheck,hscolour], sources: [hvr-ghc]}}
31+ - env: CABALVER="3.0" GHCVER="8.8.3" TESTS="lib_doc doc"
32+ compiler: ": #GHC 8.8.3"
33+ addons: {apt: {packages: [cabal-install-3.0,ghc-8.8.3,cppcheck,hscolour], sources: [hvr-ghc]}}
34+ - env: CABALVER="3.0" GHCVER="8.8.3" TESTS="test_js"
35+ compiler: ": #GHC 8.8.3"
36+ addons: {apt: {packages: [cabal-install-3.0,ghc-8.8.3,cppcheck,hscolour], sources: [hvr-ghc]}}
37+ - env: CABALVER="3.0" GHCVER="8.8.3" TESTS="test_c"
38+ compiler: ": #GHC 8.8.3"
39+ addons: {apt: {packages: [cabal-install-3.0,ghc-8.8.3,cppcheck,hscolour], sources: [hvr-ghc]}}
40+ - env: CABALVER="3.0" GHCVER="8.8.3" IDRIS2=YES
41+ addons: {apt: {packages: [cabal-install-3.0,ghc-8.8.3], sources: [hvr-ghc]}}
47+ - $HOME/.cabal/packages
51+ - rm -fv $HOME/.cabal/packages/hackage.haskell.org/build-reports.log
52+ - rm -fv $HOME/.cabal/packages/hackage.haskell.org/00-index.tar
2before_install:
54before_install:
3− - sudo add-apt-repository --yes ppa:h-rayflood/llvm
55+ - nvm install 6
4− - sudo apt-get update -qq
56+ - nvm use 6
5− - sudo apt-get install -qq libgc-dev llvm-3.3
57+ - unset CC
6− - sudo apt-get install -qq libghc-unordered-containers-dev libghc-mtl-dev libghc-network-dev libghc-xml-dev libghc-transformers-dev libghc-text-dev libghc-utf8-string-dev libghc-vector-dev libghc-split-dev libghc-ansi-terminal-dev libghc-ansi-wl-pprint-dev
58+ - if [[ $TRAVIS_OS_NAME == 'linux' ]];
7− # trifecta dependencies
59+ then
8− - sudo apt-get install -qq libghc-blaze-builder-dev libghc-blaze-html-dev libghc-data-lens-dev libghc-bifunctors-dev libghc-hashable-dev libghc-semigroups-dev libghc-semigroupoids-dev libghc-parallel-dev libghc-comonad-dev libghc-terminfo-dev libghc-keys-dev
60+ export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$HOME/.cabal/bin:$HOME/opt/scheme/bin/:$PATH;
65+ - if [[ $TRAVIS_OS_NAME == 'osx' ]];
67+ brew outdated pkgconfig || brew install pkgconfig;
68+ brew install ghc cabal-install libffi cppcheck gnu-sed;
69+ export PATH=$HOME/.cabal/bin:$PATH;
72+ export PKG_CONFIG_PATH=/usr/local/opt/libffi/lib/pkgconfig:$PKG_CONFIG_PATH;
74+ - if [ -n "$STYLISH" ]; then ./stylize.sh; exit $?; fi
75+ - if [ -n "$IDRIS2" ];
77+ git clone https://github.com/edwinb/Idris2 &&
78+ wget https://github.com/cisco/ChezScheme/archive/v9.5.2.tar.gz &&
79+ tar xvzf v9.5.2.tar.gz &&
80+ cd ChezScheme-9.5.2 &&
81+ ./configure --threads --installprefix=$HOME/opt/scheme &&
85+ travis_wait cabal v1-install &&
87+ make idris2 && make base && make contrib;
95+ - echo "$(ghc --version) [$(ghc --print-project-git-commit-id 2> /dev/null || echo '?')]"
96+ - if [ -f $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz ];
98+ $ZCAT $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz >
99+ $HOME/.cabal/packages/hackage.haskell.org/00-index.tar;
101+ - travis_retry cabal update -v
102+ # Run build with 2 parallel jobs
103+ # The container environment reports 16 cores,
104+ # causing cabal's default configuration (jobs: $ncpus)
105+ # to run into the GHC #9221 bug which can result in longer build-times.
106+ - $SED -i -r 's/(^jobs:).*/\1 2/' $HOME/.cabal/config
107+ - cabal v1-install -f FFI --only-dependencies --enable-tests --dry -v > installplan.txt
108+ - $SED -i -e '1,/^Resolving /d' installplan.txt; cat installplan.txt
109+ # check whether current requested install-plan matches cached package-db snapshot
110+ - if diff -u installplan.txt $HOME/.cabsnap/installplan.txt;
112+ echo "cabal build-cache HIT";
114+ cp -a $HOME/.cabsnap/ghc $HOME/.ghc;
115+ cp -a $HOME/.cabsnap/lib $HOME/.cabsnap/share $HOME/.cabsnap/bin $HOME/.cabal/;
117+ echo "cabal build-cache MISS";
118+ rm -rf $HOME/.cabsnap;
119+ mkdir -p $HOME/.ghc $HOME/.cabal/lib $HOME/.cabal/share $HOME/.cabal/bin;
10− - cabal install -f FFI -f LLVM --only-dependencies --enable-tests
120+ cabal v1-install -f FFI --only-dependencies --enable-tests;
122+ # snapshot package-db on cache miss
123+ - if [ ! -d $HOME/.cabsnap ];
125+ echo "snapshotting package-db to build-cache";
126+ mkdir $HOME/.cabsnap;
127+ cp -a $HOME/.ghc $HOME/.cabsnap/ghc;
128+ cp -a $HOME/.cabal/lib $HOME/.cabal/share $HOME/.cabal/bin installplan.txt $HOME/.cabsnap/;
11before_script:
132before_script:
133+ - ORIGINAL_DIR=$(pwd)
12− - cabal sdist
134+ - cabal v1-sdist
14− - tar -xf Idris-dev/dist/idris*.tar.gz
136+ - tar -xf ${ORIGINAL_DIR}/dist/${PKGNAME}*.tar.gz
15− - cd idris*
137+ - cd ${PKGNAME}*
139+ - export LD_PRELOAD=/opt/ghc/${GHCVER}/lib/ghc-${GHCVER}/rts/libffi.so.7
141+ - echo 'Configure...' && echo -en 'travis_fold:start:script.configure\\r'
17− - cabal configure -f FFI -f LLVM
142+ - cabal v1-configure -f FFI -f CI --enable-tests
143+ - echo -en 'travis_fold:end:script.configure\\r'
145+ - echo 'Build...' && echo -en 'travis_fold:start:script.build\\r'
18− - cabal build
146+ - cabal v1-build
147+ - echo -en 'travis_fold:end:script.build\\r'
149+ - echo 'Copy...' && echo -en 'travis_fold:start:script.copy\\r'
19− - cabal copy
150+ - cabal v1-copy
20− - make -j2 $TESTS
151+ - echo -en 'travis_fold:end:script.copy\\r'
22− # TESTS=doc
153+ - echo 'Register...' && echo -en 'travis_fold:start:script.register\\r'
155+ - echo -en 'travis_fold:end:script.register\\r'
157+ - echo 'Cppcheck...' && echo -en 'travis_fold:start:script.cppcheck\\r'
23− - TESTS=test_c
158+ - if [[ "$TESTS" == "test_c" ]]; then
24− - TESTS=test_java
159+ cppcheck -i 'mini-gmp.c' rts;
25− - TESTS=test_llvm
160+ fi
26− - TESTS=test_js
161+ - echo -en 'travis_fold:end:script.cppcheck\\r'
163+ - echo 'Tests...' && echo -en 'travis_fold:start:script.tests\\r'
164+ - for test in $TESTS; do
165+ echo "make TEST-JOBS=2 $test";
166+ travis_wait make TEST-JOBS=2 $test;
168+ - echo -en 'travis_fold:end:script.tests\\r'
170+ - echo 'Benchmarks...' && echo -en 'travis_fold:start:script.benchmarks\\r'
171+ - if [[ "$TESTS" == "test_c" ]]; then
172+ cd benchmarks && ./build.pl && ./run.pl && cd ..;
174+ - echo -en 'travis_fold:end:script.benchmarks\\r'
@@ -1,315 +0,0 @@
4−* Proof search now works for metavariables in types, giving some interactive
6−* New 'Lazy' type, replacing laziness annotations.
11−* Agda-style equational reasoning (in Syntax.PreorderReasoning)
12−* 'case' construct now abstracts over the scrutinee in its type
13−* Added label type 'name (equivalent to the empty type).
14− This is intended for field/effect disambiguation. "name" can be any
15− valid identifier. Two labels are definitionally equal if they have the
17−* General improvements in error messages, especially %error_reverse
18− annotation, which allows a hint as to how to display a term in error
20−* --ideslave mode now transmits semantic information about many of the
21− strings that it emits, which can be used by clients to implement
22− semantic highlighting like that of the REPL. This has been implemented
23− in the Emacs mode and the IRC bot, which can serve as examples.
24−* New expression form: with NAME EXPR privileges the namespace NAME
25− when disambiguating overloaded names. For example, it is possible to
26− write "with Vect [1,2,3]" at the REPL instead of "the (Vect _ _) [1,2,3]",
27− because the Vect constructors are defined in a namespace called Vect.
28−* assert_smaller internal function, which marks an expression as smaller than
29− a pattern for use in totality checking.
30− e.g. "assert_smaller (x :: xs) (f xs)" asserts that "f xs" will always be
31− structurally smaller than "(x :: xs)"
32−* assert_total internal function, which marks a subexpression as assumed to
33− be total, e.g "assert_total (tail (x :: xs))".
34−* Terminal width is automatically detected if Idris is compiled with curses
35− support. If curses is not available, automatic mode assumes 80 columns.
36−* Changed argument order for Prelude.Either.either.
37−* Experimental 'neweffects' library, intended to replace 'effects' in the
44−* Pretty-printer now used for all term output
50−* Type classes now implemented as dependent records, meaning that method
51− types may now depend on earlier methods.
52−* More flexible class instance resolution, so that function types and lambda
53− expressions can be made instances of a type class.
54−* Add !expr notation for implicit binding of intermediate results in
55− monadic/do/etc expressions.
56−* Extend Effects package to cope with possibly failing operations, using
57− "if_valid", "if_error", etc.
58−* At the REPL, "it" now refers to the previous expression.
59−* Semantic colouring at the REPL. Turn this off with --nocolour.
60−* Some prettifying of error messages.
61−* The contents of ~/.idris/repl/init are run at REPL start-up.
62−* The REPL stores a command history in ~/.idris/repl/history.
63−* The [a..b], [a,b..c], [a..], and [a,b..] syntax now pass the totality
64− checker and can thus be used in types. The [x..] syntax now returns an
65− actually infinite stream.
66−* Add '%reflection' option for functions, for compile-time operations on
68−* Add expression form 'quoteGoal x by p in e' which applies p to the expected
69− expression type and binds the result to x in the scope e.
70−* Performance improvements in Strings library.
71−* Library reorganisation, separated into prelude/ and base/.
75−* New module/dependency tree checking.
76−* New parser implementation with more precise errors.
77−* Improved type class resolution.
78−* Compiling Nat via GMP integers.
79−* Performance improvements in elaboration.
80−* Improvements in termination checking.
81−* Various REPL commands to support interactive editing, and a client/server
82− mode to allow external invocation of REPL commands.
87−* Apply functions by return type, rather than with arguments:
88− "t <== f" means "apply f with arguments such that it returns a value
90−* Allow the result type of a rewrite to be specified
91−* Allow names to be attached to provisional definitions
92− lhs ?= {name} rhs -- generates a lemma called 'name' which makes the
93− types of the lhs and rhs match. {name} is optional - a unique name is
94− generated if it is absent.
95−* Experimental LLVM backend
96−* Added Data.HVect module
97−* Fix fromInteger to take an Integer, rather than an Int
98−* Integer literals for Fin
99−* Renamed O to Z, and fO to fZ
100−* Swapped Vect arguments, now Vect : Nat -> Type -> Type
101−* Added DecEq instances
102−* Add 'equiv' tactic, which rewrites a goal to an equivalent (convertible) goal
106−* Add annotation for unification traces
107−* Add 'mrefine' tactic for refining by matching against a type
108−* Type class resolution fixes
109−* Much faster coverage checking
114−User visible changes:
116−* Added "rewrite ... in ..." construct
117−* Allow type class constraints in 'using' clauses
118−* Renamed EFF to EFFECT in Effect package
119−* Experimental Java backend
120−* Tab completion in REPL
121−* Dynamic loading of C libraries in the interpreter
122−* Testing IO actions at the REPL with :x command
123−* Improve rendering of :t
124−* Fixed some INTERNAL ERROR messages
128−* Fix non-linear pattern checking
129−* Improved name disambiguation
130−* More flexible unification and elaboration of lambdas
131−* Various unification and totality checking bug fixes
136−User visible changes:
138−* 'implicit' keyword, for implicit type conversion
139−* Added Effects package
140−* Primitives for 8,16,32 and 64 bit integers
144−* Change unification so that it keeps track of failed constraints in case
145− later information helps to resolve them
146−* Distinguishing parameters and indices in data types
147−* Faster termination/coverage checking
148−* Split 'javascript' target into 'javascript' and 'node'
153−User visible changes:
155−* The type of types is now 'Type' rather than 'Set'
156−* Forward declarations of data allowed
157− - supporting induction recursion and mutually recursive data
158−* Type inference of definitions in 'where' clauses
159− - Provided that the type can be completely determined from the first
160− application of the function (in the top level definition)
161−* 'mutual' blocks added
162− - effect is to elaborate all types of declarations in the block before
163− elaborating their definitions
164− - allows inductive-recursive definitions
165−* Expression inspected by 'with' clause now abstracted from the goal
167−* Implicit arguments will be added automatically only if their initial
168− letter is lower case, or they are in a using declaration
169−* Added documentation comments (Haddock style) and ':doc' REPL command
170−* Pattern matching on strings, big integers and characters
171−* Added System.Concurrency modules
172−* Added 'postulate' declarations
173−* Allow type annotations on 'let' tactic
174−* EXPERIMENTAL JavaScript generation, with '--target javascript' option
178−* Separate inlining methods at compile-time and run-time
179−* Fixed nested parameters blocks
180−* Improve efficiency of elaborator by:
181− - only normalising when necessary
182− - reducing backtracking with resolving ambiguities
183−* Better compilation of case trees
188−User visible changes:
191− - as data declarations, but constructor arguments are evaluated lazily
192− - functions which return a codata type do not reduce at compile time
193−* Added 'parameters' blocks
194−* Allow local data definitions in where blocks
195−* Added '%default' directive to declare total-by-default or partial-by-default
196− for functions, and a corresponding "partial" reserved words to mark functions
197− as allowed to be partial. Also "--total" and "--partial" added as command
199−* Command line option "--warnpartial" for flagging all undeclared
200− partial functions, without error.
201−* New termination checker supporting mutually recursive definitions.
202−* Added ':load' command to REPL, for loading a new file
203−* Added ':module' command to REPL, for adding modules
204−* Renamed library modules (now have initial capital)
208−* Several improvements and fixes to unification
209−* Added collapsing optimisation and more aggressive erasure
214−User visible changes:
216−* Simple packaging system
217−* Added --dumpc flag for displaying generated code
221−* Improve overloading resolution (especially where this is a type error)
222−* Various important bug fixes with evaluation and compilation
223−* More aggressive compile-time evaluation
228−User visible changes:
230−* Added binding forms to syntax rules
231−* Named class instances
232−* Added ':set' command, with options 'errorcontext' for displaying local
233− variables in scope when a unification error occurs, and 'showimplicits'
234− for displaying elaborated terms in full
235−* Added '--errorcontext' command line switch
236−* Added ':proofs' and ':rmproofs' commands
237−* Various minor REPL improvements and fixes
241−* Completely new run time system (not based on Epic or relying on Boehm GC)
242−* Normalise before forcing to catch more forceable arguments
243−* Types no longer exported in normal form
244−* Try to resolve overloading by inspecting types, rather than full type
250−User visible changes:
252−* backtick notation added: x `foo` y ==> foo x y
253−* case expressions allowed in type signatures
254−* Library extensions in prelude.vect and prelude.algebra
255−* malloc/trace_malloc added to builtins.idr
259−* Some type class resolution fixes
260−* Several minor bug fixes
261−* Performance improvements in resolving overloading and type classes
266−User visible changes:
268−* DSL notation, for overloading lambda and let bindings
269−* Dependent records, with projection and update
270−* Totality checking and 'total' keyword
271−* Auto implicits and default argument values {auto n : T}, {default val n : T}
272−* Overlapping type class instances disallowed
273−* Many extensions to prelude.nat and prelude.list libraries (mostly thanks to
275−* New libraries: control.monad.identity, control.monad.state
276−* Small improvements in error reporting
280−* Faster compilation (only compiling names which are used)
281−* Better type class resolution
282−* Lots of minor bug fixes
286−Complete rewrite. User visible changes:
288−* New proof/tactics syntax
289−* New syntax for pairs/dependent pairs
290−* Indentation-significant syntax
292−* Added where clauses
293−* Added case expressions, pattern matching let and lambda
294−* Added monad comprehensions
295−* Added cumulativity and universe checking
296−* Ad-hoc name overloading
297− - Resolved by type or explicit namespace
298−* Modules (Haskell-style)
299−* public, abstract and private access to functions and types
300−* Separate type-checking
301−* Improved interactive environment
302−* Replaced 'do using' with Monad class
303−* Extended syntax macros
308−* All definitions (functions, classes and instances) are elaborated to top
309− level, fully explicit, data declarations and pattern matching definitions,
310− which are verified by a minimal type checker.
312−This is the first release of a complete reimplementation. There will be bugs.
313−If you find any, please do not hesitate to contact Edwin Brady
314−(ecb10@st-andrews.ac.uk).
CHANGELOG.mdnew file+1290
@@ -0,0 +1,1290 @@
1+# New since last release
2++ Updated to work with GHC 8.8 and cabal 3.0
5++ Documentation added to proof section
8++ `openFile` opens the file in binary mode on Windows.
9++ Added library functions `clockTime` and `fRemove`
12++ Modules no longer require building if imports have changed but all
13+ interfaces (i.e. types for names declared `export` and definitions of names
14+ declared `public export`) are unchanged.
15++ The result of calling `:doc` now details the accessbility of items as well as their totality.
17+## Miscellaneous updates
18++ Compiler flag `--optimise-nat-like-types` enables compilation
19+ of `Nat`-like type families to big integers. A type family
20+ is `Nat`-like if, after erasure, it has two constructors,
21+ one nullary, the other one with exactly one recursive field.
26++ Fixes for building with GHC 8.6
27++ Fix for megaparsec update
28++ Some fixes for memory allocation issues in the C back end
33++ Old 'induction' tactics and eliminator generation functionality ('%elim', '%case', 'elim_for') is no longer supported.
34+ Please, rely on the ones provided by Pruviloj and elaborator reflection instead.
38++ Changed rndInt in Effect.Random so that it does not alternate between odd
40++ Additions to `contrib`:
41+ * `Data.SortedBag`: Bag (or Multiset) implemention based on `Data.SortedMap`.
42+ * `Data.PosNat`: A `Nat` paired with a proof that it is positive.
43+ * `Data.Chain`: A function with an arbitrary number of arguments, plus
44+ combinators for working with them.
47++ Added a switch `--allow-capitalized-pattern-variables` to optionally allow capitalized pattern variables after they were prohibited in 1.2.0.
48++ REPL now prints an error message if program compiled by `:exec` terminates
50++ Idris now builds with GHC 8.4.
51++ In the C backend, the representation of Idris values at runtime has been reworked.
57++ In `@`-patterns such as `x@p`, `x` is now in scope on the right-hand side
58+ of any definitions in `where` clauses, provided the left-hand side of the
59+ definition does not shadow it.
60++ The `LinearTypes` language extension has been revised. It implements the
61+ rules from Bob Atkey's draft "The Syntax and Semantics of Quantitative
62+ Type Theory" and now works with holes and case expressions.
63++ Backticked operators can appear in sections, e.g. ``(`LTE` 42)`` or
65++ Backticked operators can have their precendence and associativity set like
66+ other operators, e.g. ``infixr 8 `cons` ``. Backticked operators with
67+ undeclared fixity are treated as non-associative with precedence lower
68+ than all declared operators.
69++ Allow non-injective implementations if explicitly named, e.g.,
72+ LTB b = DPair Nat (\ n => LT n b)
74+ implementation [uninhabltb] Uninhabited (LTB Z) where
75+ uninhabited (MkDPair n prf) = absurd prf
77+ It is possible to use `using implementation uninhabltb` to add the
78+ implementation to the automated resolution, but if it fails to find the
79+ instance due to non-injectivity, one must pass it explicitly to target
80+ function, i.e. `absurd @{uninhabltb}`.
81++ Verbatim strings now support trailing quote characters. All quote characters
82+ until the final three are considered part of the string. Now a string such as
83+ `""""hello""""` will parse, and is equivalent to `"\"hello\""`.
84++ C FFI now supports pasting in any expression by prefixing it with '#', e.g.
87+ intMax = foreign FFI_C "#INT_MAX" (IO Int)
89++ The deprecated keywords `%assert_total`, `abstract`, and `[static]` have
90+ been removed as well as the use of "public" instead of "public export" to
92++ The syntax for pattern-match alternatives now works for `let` statements in
93+ `do` blocks in addition to `let` expressions and `<-` statements, e.g.
96+ let Just x = expr | Nothing => empty
99+ This means that a `with`-application (using `|`) cannot be used in that
104++ Removed `oldeffects` library from `libs` folder, use `effects` or `Control.ST` instead.
105++ Added `Text.Literate`, a module for working with literate source files.
106++ Added `Data.IORef`, for working with mutable references in `IO` and `JS_IO`.
107++ Added `discriminate` and `construct` tactics to Pruviloj.
108++ Added `IsSucc` type to `Prelude`, which proves that a `Nat` is a successor.
109++ Added `Data.IOArray`, containing primitives for mutable arrays.
110++ Added `Language.JSON`, for total serialization/deserialization of JSON data.
111++ Reworked operator fixity for many operators.
112+ * Changed `&&` and `||` to be right-associative. Increased precedence of `&&`
113+ to be higher than that of `||`.
114+ * Removed associativity from Boolean comparison operators `==`, `/=`, `<`, `<=`,
115+ `>`, and `>=`. Increased precedence of `/=` and `==` to match the others.
116+ * Made `<|>`, `<$>`, and `.` right-associative.
117+ * Swapped precedence of `<|>` and `<*>` (and its related operators, `<*` and
118+ `*>`). Now `<|>` has a lower precedence.
119+ * Lowered the precedence of `>>=` to be below that of `<|>`.
120++ Added some useful string manipulation functions to `Data.String.Extra`.
121++ Added `Control.Delayed`, a module for conditionally making a type `Inf` or `Lazy`.
122++ Added `Data.Fuel`, which implements the `Fuel` data type and the partial `forever` function.
123++ Added `Data.Bool.Extra`, a module with properties of boolean operations.
124++ Moved core of `Text.Lexer` to `Text.Lexer.Core`. Added several new combinators
125+ and lexers to `Text.Lexer`.
126++ Moved core of `Text.Parser` to `Text.Parser.Core`. Added several new combinators
127+ to `Text.Parser`. Made the following changes.
128+ * Flipped argument order of `parse`.
129+ * Renamed `optional` to `option` and flip argument order.
130+ * Renamed `maybe` to `optional`.
131+ * Generalised many combinators to use an unknown `commit` flag where possible.
132++ `Prelude.Doubles.atan2` is now implemented as a primitive instead of
133+ being coded in Idris.
134++ Added `Test.Unit` to `contrib` for simple unit testing.
135++ Removed several deprecated items from the libraries shipped with Idris.
136++ Moved `abs` from the `Neg` interface into its own `Abs` interface. `Nat`
137+ implements `Abs` with `abs = id`.
138++ Added `Control.ST.File`, an ST based implementation of the same behaviour
139+ implemented by `Effect.File` in the effects package.
143++ Private functions are no longer visible in the REPL except for modules
144+ that are explicitly loaded.
145++ The --interface option now creates CommonJS modules on the node backend.
146++ The C backend now pass arguments to the C compiler in the same order
147+ as they were given in the source files.
148++ Backslash, braces and percent symbols are now correctly pretty printed
150++ Errors and warnings now consistently have the following format:
154+ 1 | data nat : Type where --error
156+ Main.nat has a name which may be implicitly bound.
157+ This is likely to lead to problems!
159+ The code is highlighted when highlighting information is available. How
160+ much highlighting information is available depends on where the error
162++ The parser provider has been switched from Trifecta to Megaparsec. This
163+ could possibly cause some subtle deviations in parsing from previous
165++ Many more errors now report beginning *and* ending position (which may be
166+ on different lines), instead of just a single point. The format is
167+ `Foo.idr:9:7-15:` if ending column is on the same line or
168+ `Foo.idr:9:7-10:15:` if the ending column is on a different line.
169++ Error messages were changed so that the last column is inclusive, e.g.
170+ `Foo.idr:9:7-15:` includes column 15. Previously the error would have read
175++ Package names now only accept a restrictive charset of letters, numbers and the `-_` characters.
176+ Package names are also case insensitive.
177++ When building makefiles for the FFI, the environment variables
178+ `IDRIS_INCLUDES` and `IDRIS_LDFLAGS` are now set with the correct C
183++ Erasure analysis is now faster thanks to a bit smarter constraint solving.
184++ Fixed installation issue
185++ Fixed a potential segfault when concatenating strings
191++ Added `Text.PrettyPrint.WL` an implementation of the Wadler-Leijen
192+ Pretty-Print algorithm. Useful for those wishing to pretty print
194++ Added `Text.Lexer` and `Text.Parser` to `contrib`. These are small libraries
195+ for implementing total lexical analysers and parsers.
197+ + Added `Catchable` for `ReaderT`, `WriterT`, and `RWST`.
198+ + Added `MonadTrans` for `RWST`.
199++ Added utility functions to `Data.SortedMap` and `Data.SortedSet` (`contrib`),
200+ most notably `merge`, merging two maps by their `Semigroup` op (`<+>`)
201++ `Prelude.WellFounded` now contains an interface `Sized a` that defines a size
202+ mapping from `a` to `Nat`. For example, there is an implementation for lists,
203+ where `size = length`.
205+ The function `sizeAccessible` then proves well-foundedness of the relation
206+ `Smaller x y = LT (size x) (size y)`, which allows us to use strong
207+ induction conveniently with any type that implements `Sized`.
209+ In practice, this allows us to write functions that recurse not only on
210+ direct subterms of their arguments but on any value
211+ with a (strictly) smaller `size`.
213+ A good example of this idiom at work is `Data.List.Views.splitRec` from `base`.
214++ Added utility lemma `decEqSelfIsYes : decEq x x = Yes Refl` to
215+ `Decidable.Equality`. This is primarily useful for proving properties of
216+ functions defined with the help of `decEq`.
220++ New JavaScript code generator that uses an higher level intermediate
223++ Various optimizations of the new JavaScript code generator.
225++ Names are now annotated with their representations over the IDE
226+ protocol, which allows IDEs to provide commands that work on special
227+ names that don't have syntax, such as case block names.
238++ Added `Data.Buffer` to `base`. This allows basic manipulation of mutable
239+ buffers of `Bits8`, including reading from and writing to files.
243++ Idris now checks the list of packages specified at the command line
244+ against those installed. If there is a mismatch Idris will complain.
246+## Miscellaneous Updates
248++ Documentation updates for the new `Control.ST` library
249++ Various stability/efficiency fixes
255+* Language pragmas now required for the less stable existing features, in
256+ addition to the existing `TypeProviders` and `ErrorReflection`:
257+ + `ElabReflection`, which must be enabled to use `%runElab`
258+ + `UniquenessTypes`, which must be enabled to use `UniqueType`
259+ + `DSLNotation`, which must be enabled to define a `dsl` block
260+ + `FirstClassReflection`, which must be enabled to define a `%reflection`
263+* New language extension `LinearTypes`:
264+ + This allows adding a /multiplicity/ to a binder which says how often it
265+ is allowed to be used; either 0 or 1 (if unstated, multiplicity is "many")
266+ + The typing rules follow Conor McBride's paper "I Got Plenty o' Nuttin'"
267+ + This is highly experimental, unfinished, not at all polished. and there
268+ are still lots of details to sort out. Some features don't quite work
269+ properly yet. But it is there to play with for the brave!
273++ Idris' output has been updated to more accurately reflect its
274+ progress through the compiler i.e. Type Checking; Totality Checking;
275+ IBC Generation; Compiling; and Code Generation. To control the
276+ loudness of the reporting three verbosity levels are introduced:
277+ `--V0`, `--V1`, and `--V2`. The old aliases of `-V` and `--verbose`
280++ New REPL command `:!` that runs an external shell command.
282++ The REPL now colourises output on MinTTY consoles (e.g., Cygwin and MSYS)
283+ on Windows, which previously did not occur due to a bug.
285++ Idris now runs in a UTF-8-compatible codepage on Windows. This fixes many
286+ Unicode-rendering issues on Windows (e.g., error messages stating
287+ `commitBuffer: invalid argument (invalid character)`).
289++ Idris now has a `--warnipkg` flag to enable auditing of Idris
290+ packages during build time. Currently auditing check's the list of
291+ modules specified in the `iPKG` file with those presented in the
296++ Terminating programs has been improved with more appropriate
297+ functions (`exitWith`, `exitFailure`, and `exitSuccess`) and a data
298+ structure (`ExitCode`) to capture a program's return code.
299++ Casting a `String` to an `Int`, `Integer` or a `Double` now ignores leading
300+ and trailing whitespace. Previously only leading whitespace was ignored.
301++ RTS functions `openFile`, `do_popen`, and `ARGV` are now properly encoded using UTF-8 on Windows.
307+* `record` syntax now allows updating fields, including nested fields,
308+ by applying a function using the `$=` operator. For example:
316+ record GameState where
317+ constructor MkGameState
321+ correct : GameState -> GameState
322+ correct st = record { score->correct $= (+1),
323+ score->attempted $= (+1) } st
326+* Implicit parameter to interfaces are now allowed. For example:
329+ interface Shows (ts : Vect k Type) where
330+ shows : HVect ts -> Vect k String
332+ In this interface, `k` is an implicit parameter, but previously needed to
338+* The File Effect has been updated to take into account changes in
339+ `Prelude.File` and to provide a 'better' API.
340+* `natEnumFromThen` and `natEnumFromTo` have been updated to correctly calculate reverse ranges. Range syntax `[a,b..c]` now can be used again to generate reverse ranges.
341+* `divBN` and `modBN` now can only be used for unsigned numbers.
342+* `return`, which has been an alias for `pure` for many releases, is now deprecated.
343+* Replace instance with implementation:
344+ + `InstanceN` is deprecated, use `ImplementationN` instead.
345+ + `InstanceCtorN` is deprecated, use `ImplementationCtorN` instead.
346+ + `addInstance` is deprecated, use `addImplementation` instead.
347+ + `%instance` keyword is deprecated, use `%implementation` instead.
349+* Idris packages are now installed within a sub-directory `libs` of Idris' data directory, before they were installed in the directory's root.
353+* Idris' documentation system now displays the documentation for auto
354+ implicits in the output of `:doc`. This is tested for in `docs005`.
355+* New command line flag `--info` that displays information about the installation.
356+* New command line flag `--sourcepath <dir>` that allows adding directories to the source search path.
357+* Allow 'installation' of a package's IdrisDoc documentation into a central location. The default location is the subdirectory `docs` of Idris' data directory.
358+ * New flag `--installdoc <ipkg>` provided to install documentation
359+ * New flag `--docdir` provided to show default documentation installation location.
360+ * New environment variable `IDRIS_DOC_PATH` to allow specification of an alternative installation path for documentation.
361+* Semantic meaning behind several environment variables has been clarified in documentation and code. See compilation section of the reference manual for more details.
362+* Interface parameter constraints are now printed in the output of `:doc`. This
363+ is tested for in `docs006`.
365+## Miscellaneous updates
367+* New, faster, better, implementation of the coverage checker
368+* The test suite now uses [tasty-golden](https://hackage.haskell.org/package/tasty-golden). New tests must be registered in `test/TestData.hs`, as explained in the relevant `README.md`.
369+* Added OSX and Windows continous integration with Travis and Appveyor.
373+* The :e command can now handle an $EDITOR with arguments in it, like "emacs -nw"
380+* `rewrite` can now be used to rewrite equalities on functions over
382+* `rewrite` can now be given an optional rewriting lemma, with the syntax
383+ `rewrite [rule] using [rewrite_lemma] in [scope]`.
385+* Reorganised elaboration of `implementation`, so that interfaces with
386+ dependencies between methods now work more smoothly
388+* Allow naming of parent implementations when defining an implementation.
392+ [PlusNatSemi] Semigroup Nat where
395+ [MultNatSemi] Semigroup Nat where
398+ -- use PlusNatSemi as the parent implementation
399+ [PlusNatMonoid] Monoid Nat using PlusNatSemi where
402+ -- use MultNatSemi as the parent implementation
403+ [MultNatMonoid] Monoid Nat using MultNatSemi where
407+* Interface definitions can now include data declarations (but not data
408+ definitions). Any implementation of the interface must define the method
409+ using a data type. The effect is to cause Idris to treat the method as
410+ a data type (for unification and interface resolution purposes).
412+* Experimentally, allow named implementations to be available by default in a
413+ block of declarations with `using` notation. For example:
416+ using implementation PlusNatMonoid
418+ test x = x <+> x <+> neutral
421+* Constraint arguments can now appear anywhere in function types, not just
422+ at the top level or after an implicit argument binding.
424+* Experimental extended `with` syntax, which allows calling functions defined
425+ in a with block directly. For example:
428+ data SnocList : List a -> Type where
430+ Snoc : SnocList xs -> SnocList (xs ++ [x])
432+ snocList : (xs : List a) -> SnocList a
434+ my_reverse : List a -> List a
435+ my_reverse xs with (snocList xs)
436+ my_reverse [] | Empty = []
437+ my_reverse (ys ++ [x]) | (Snoc p) = x :: my_reverse ys | p
440+ The `| p` on the right hand side means that the `with` block function will
441+ be called directly, so the recursive structure of `SnocList` can direct the
442+ recursion structure of `my_reverse`.
444+* Added `%fragile` directive, which gives a warning and a message when a
445+ fragile name is referenced. For use in detailing fragile APIs.
447+* The totality checker now looks under `case` blocks, rather than treating
448+ them as mutually defined functions with their top level function, meaning
449+ that it can spot more total functions.
451+* The totality checker now looks under `if...then...else` blocks when checking
454+* The `%assert_total` directive is now deprecated. Instead, you can
455+ use one of the functions `assert_total`, `assert_smaller` or
456+ `assert_unreachable` to describe more precisely where a totality assertion
461+* `Control.WellFounded` module removed, and added to the Prelude as
462+ `Prelude.WellFounded`.
463+* Added `Data.List.Views` with views on `List` and their covering functions.
464+* Added `Data.Nat.Views` with views on `Nat` and their covering functions.
465+* Added `Data.Primitives.Views` with views on various primitive types and their covering functions.
466+* Added `System.Concurrency.Sessions` for simple management of conversations
471+* Taking cues from cabal, the `iPKG` format has been extended to
472+ include more package metadata information. The following fields
475+ + `brief`: Brief description of the package.
476+ + `version`: Version string to associate with the package.
477+ + `readme`: Location of the README file.
478+ + `license`: Description of the licensing information.
479+ + `author`: Author information.
480+ + `maintainer`: Maintainer information.
481+ + `homepage`: Website associated with the package.
482+ + `sourcepage`: Location of the DVCS where the source can be found.
485+## Miscellaneous updates
487+* The Idris man page is now installed as part of the cabal/stack build process.
489+* Improved startup performance by reducing the processing of an already imported
490+ module that has changed accessibility.
492+* A limited set of command line options can be used to override
493+ package declared options. Overridable options are currently, logging
494+ level and categories, default totality check, warn reach, IBC output
495+ folder, and idris path. Note overriding IBC output folder, only
496+ affects the installation of Idris packages.
498+* Remove deprecated options `--ideslave` and `--ideslave-socket`. These options
499+ were replaced with `--ide-mode` and `--ide-mode-socket` in 0.9.17
501+* The code generator output type `MavenProject` was specific to the
502+ Java codegen and has now been deprecated, together with the
503+ corresponding `--mvn` option.
505+* Definitional equality on Double is now bit-pattern identity rather
506+ than IEEE's comparison operator. This prevents a bug where programs
507+ could distinguish between -0.0 and 0.0, but the type theory could
508+ not, leading to a contradiction. The new fine-grained equality
511+* Naming conventions for Idris packages in an iPKG file now follow the
512+ same rules for executables. Unquoted names must be valid namespaced
513+ Idris identifiers e.g. ``package my.first.package``. Quoted package
514+ names allow for packages to be given valid file names, for example,
515+ ``package "my-first-package"``.
517+## Reflection changes
519+* The implicit coercion from String to TTName was removed.
521+* Decidable equality for TTName is available.
525+## Updated export rules
527+* The export rules are:
528+ - 'private' means that the definition is not exported at all
529+ - 'export' means that the top level type is exported, but not the
530+ definition. In the case of 'data', this means the type constructor is
531+ exported but not the data constructors.
532+ - 'public export' means that the entire definition is exported.
533+* By default, names are 'private'. This can be altered with an %access directive
535+* Exported types can only refer to other exported names
536+* Publicly exported definitions can only refer to publicly exported names
540+* Idris functions can now be passed as callbacks to C functions or wrapped in a
542+* C function pointers can be called.
543+* Idris can access pointers to C globals.
547+* Effects can now be given in any order in effect lists (there is no need for
548+ the ordering to be preserved in sub lists of effects)
550+## Elaborator reflection updates
552+* Datatypes can now be defined from elaborator reflection:
553+ - declareDatatype adds the type constructor declaration to the context
554+ - defineDatatype adds the constructors to the datatype
555+ - To declare an inductive-recursive family, declare the types of the function
556+ and the type constructor before defining the pattern-match cases and
559+## Minor language changes
561+* The `[static]` annotation is changed to `%static` to be consistent with the
563+* Added `%auto_implicits` directive. The default is `%auto_implicits on`.
564+ Placing `%auto_implicits off` in a source file means that after that point,
565+ any implicit arguments must be bound, e.g.:
568+ append : {n,m,a:_} -> Vect n a -> Vect m a -> Vect (n + m) a
571+ Only names which are used explicitly in the type need to be bound, e.g.:
574+ Here : {x, xs : _} -> Elem x (x :: xs)
577+ In `Here`, there is no need to bind any of the variables in the type of `xs`
578+ (it could be e.g. `List a` or `Vect n a`; `a` and `n` will still be implicitly
581+ You can still implicitly bind with 'using':
584+ using (xs : Vect _ _)
585+ data Elem : {a, n : _} -> a -> Vect n a -> Type where
586+ Here : {x : _} -> Elem x (x :: xs)
587+ There : {x, y : _} -> Elem x xs -> Elem x (y :: xs)
590+ However, note that *only* names which appear in *both* the using block
591+ *and* the type being defined will be implicitly bound. The following will
592+ therefore fail because 'n' isn't implicitly bound:
595+ using (xs : Vect n a)
596+ bad : Elem x xs -> Elem x (y :: xs)
599+* `Sigma` has been renamed to `DPair`.
600+* Accessor functions for dependent pairs have been renamed to bring them into
601+ line with standard accessor functions for pairs. The function `getWitness` is
602+ now `fst`, and `getProof` is `snd`.
603+* File Modes expanded: Append, ReadWriteTruncate, and ReadAppend added, Write is
604+ deprecated and renamed to WriteTruncate.
605+* C11 Extended Mode variations added to File Modes.
606+* More flexible holes. Holes can now depend on other holes in a term (such as
607+ implicit arguments which may be inferred from the definition of the hole).
608+* Programs with holes can now be compiled. Attempting to evaluate an expression
609+ with a hole results in a run time error.
610+* Dependent pairs now can be specified using a telescope-style syntax, without
611+ requirement of nesting, e.g. it is possible to now write the following:
614+ (a : Type ** n : Nat ** Vect n a)
617+* Idris will give a warning if an implicit is bound automatically, but would
618+ otherwise be a valid expressio if the name was used as a global
620+## External Dependencies
622+* Curses has been removed as an external dependency.
626+* `class` and `instance` are now deprecated keywords. They have been replaced by
627+ `interface` and `implementation` respectively. This is to properly reflect
629+* `(/)` operator moved into new Fractional interface.
630+* Idris' logging infrastructure has been categorised. Command line and repl are
631+ available. For command line the option `--logging-categories CATS` is used to
632+ pass in the categories. Here `CATS` is a colon separated quoted string
633+ containing the categories to log. The REPL command is `logcats CATS`. Where
634+ `CATS` is a whitespace separated list of categoriese. Default is for all
635+ categories to be logged.
636+* New flag `--listlogcats` to list logging categories.
642+* Improved unification by implementing a pattern unification rule
643+* The syntax `` `{{n}}`` quotes n without resolving it, allowing short syntax for
644+ defining new names. `` `{n}`` still quotes n to an existing name in scope.
645+* A new primitive operator `prim__strSubstr` for more efficient extraction of
646+ substrings. External code generators should implement this.
647+* The previous syntax for tactic proofs and the previous interactive prover are
648+ now deprecated in favour of reflected elaboration. They will be removed at
649+ some point in the future.
650+* Changed scoping rules for unbound implicits: any name which would be a valid
651+ unbound implicit is now *always* an unbound implicit. This is much more
652+ resilient to changes in inputs, but does require that function names be
653+ explicitly qualified when in argument position.
654+* Name binding in patterns follows the same rule as name binding for implicits
655+ in types: names which begin with lower case letters, not applied to any
656+ arguments, are treated as bound pattern variables.
657+* Added `%deprecate` directive, which gives a warning and a message when a
658+ deprecated name is referenced.
662+* The `Neg` class now represents numeric types which can be negative. As such,
663+ the `(-)` operator and `abs` have been moved there from `Num`.
664+* A special version of `(-)` on `Nat` requires that the second argument is
665+ smaller than or equal to the first. `minus` retains the old behaviour,
666+ returning `Z` if there is an underflow.
667+* The `(+)`, `(-)`, and `(*)` operations on Fin have been removed.
668+* New Logging Effects have been added to facilitate logging of effectful
670+* Elaborator reflection is now a part of the prelude. It is no longer necessary
671+ to import `Language.Reflection.Elab`.
672+* The `PERF` effect allows for simple performance metrics to be collected from
674+* Some constructors that never actually occurred have been removed from the `TT`
675+ and `Raw` reflection datatypes in Language.Reflection.
676+* File `IO` operations (for example openFile/fread/fwrite) now return
677+ `Either FileError ty` where the return type was previously `ty` to indicate
682+* Records are now shown as records in `:doc`, rather than as the underlying
684+* iPKG files have a new option `pkgs` which takes a comma-separated list of
685+ package names that the idris project depends on. This reduces bloat in the
686+ `opts` option with multiple package declarations.
687+* iPKG files now allow `executable = "your filename here"` in addition to the
688+ Existing `Executable = yourFilenameHere` style. While the unquoted version is
689+ limited to filenames that look like namespaced Idris identifiers
690+ (`your.filename.here`), the quoted version accepts any valid filename.
691+* Add definition command (`\d` in Vim, `Ctrl-Alt-A` in Atom, `C-c C-s` in Emacs)
692+ now adds missing clauses if there is already a definition.
694+## Miscellaneous updates
696+* Disable the deprecation warnings for %elim and old-style tactic scripts with
697+ the `--no-elim-deprecation-warnings` and `--no-tactic-deprecation-warnings`
702+* The Idris Reference manual has been fleshed out with content originally found
704+* The `Show` class has been moved into `Prelude.Show` and augmented with the
705+ method `showPrec`, which allows correct parenthesization of showed terms. This
706+ comes with the type `Prec` of precedences and a few helper functions.
707+* New REPL command `:printerdepth` that sets the pretty-printer to only descend
708+ to some particular depth when printing. The default is set to a high number to
709+ make it less dangerous to experiment with infinite structures. Infinite depth
710+ can be set by calling :printerdepth with no argument.
711+* Compiler output shows applications of `>>=` in do-notation
712+* `fromInteger i` where `i` is an integer constant is now shown just as `i` in
714+* An interactive shell, similar to the prover, for running reflected elaborator
715+ actions. Access it with `:elab` from the REPL.
716+* New command-line option `--highlight` that causes Idris to save highlighting
717+ information when successfully type checking. The information is in the same
718+ format sent by the IDE mode, and is saved in a file with the extension ".idh".
719+* Highlighting information is saved by the parser as well, allowing it to
720+ highlight keywords like `case`, `of`, `let`, and `do`.
721+* Use predicates instead of boolean equality proofs as preconditions on `List`
723+* More flexible 'case' construct, allowing each branch to target different
724+ types, provided that the case analysis does not affect the form of any
725+ variable used in the right hand side of the case.
726+* Some improvements in interactive editing, particularly in lifting out
727+ definitions and proof search.
728+* Moved `System.Interactive`, along with `getArgs` to the Prelude.
729+* Major improvements to reflected elaboration scripts, including the ability to run
730+ them in a declaration context and many bug fixes.
731+* `decl syntax` rules to allow syntax extensions at the declaration level
732+* Experimental Windows support for console colours
736+* GHC 7.10 compatibility
737+* Add support for bundled toolchains.
738+* Strings are now UTF8 encoded in the default back end
739+* Idris source files are now assumed to be in UTF8, regardless of locale
741+* Some reorganisation of primitives:
742+ + `Buffer` and `BitVector` primitives have been removed (they were not tested
743+ sufficiently, and lack a maintainer)
744+ + `Float` has been renamed `Double` (`Float` is defined in the Prelude for
746+ + Externally defined primitives and operations now supported with `%extern`
747+ directive, allowing back ends to define their own special purpose primitives
748+ + `Ptr` and `ManagedPtr` have been removed and replaced with external primitives
749+* Add `%hint` function annotation, which allows functions to be used as hints in
750+ proof search for `auto` arguments. Only functions which return an instance of
751+ a data or record type are allowed as hints.
752+* Syntax rules no longer perform variable capture. Users of effects will need to
753+ explicitly name results in dependent effect signatures instead of using the
754+ default name `result`.
755+* Pattern-matching lambdas are allowed to be impossible. For example,
756+ `Dec (2 = 3)` can now be constructed with `No $ \(Refl)` impossible, instead of
757+ requiring a separate lemma.
758+* Case alternatives are allowed to be impossible:
761+ case Vect.Nil {a=Nat} of { (x::xs) impossible ; [] => True }
764+* The default `Semigroup` and `Monoid` instances for Maybe are now prioritised
765+ choice, keeping the first success as Alternative does. The version that
766+ collects successes is now a named instance.
767+* `:exec` REPL command now takes an optional expression to compile and run/show
768+* The return types of `Vect.findIndex`, `Vect.elemIndex` and `Vect.elemIndexBy`
769+ were changed from `Maybe Nat` to `Maybe (Fin n)`
770+* A new `:browse` command shows the contents of a namespace
771+* `` `{n}`` is syntax for a quotation of the reflected representation
772+ of the name `n`. If `n` is lexically bound, then the resulting
773+ quotation will be for it, whereas if it is not, then it will succeed
774+ with a quotation of the unique global name that matches.
775+* New syntax for records that closely matches our other record-like structures:
776+ type classes. See the updated tutorial for details.
777+* Records can be coinductive. Define coinductive records with the `corecord`
779+* Type class constructors can be assigned user-accessible names. This is done
780+ using the same syntax as record constructors.
781+* `if ... then ... else ...` is now built-in syntax instead of being defined in
782+ a library. It is shown in REPL output and error messages, rather than its
784+* The desugaring of `if ... then ... else ...` has been renamed to `ifThenElse`
785+ from `boolElim`. This is for consistency with GHC Haskell and
786+ scala-virtualized, and to reflect that if-notation makes sense with non-Bool
788+* Agda-style semantic highlighting is supported over the IDE protocol.
789+* Experimental support for elaborator reflection. Users can now script the
790+ elaborator, for use in code generation and proof automation. This feature is
791+ still under rapid development and is subject to change without notice. See
792+ Language.Reflection.Elab and the %runElab constructs
796+* The `--ideslave` command line option has been replaced with a `--ide-mode`
797+ command line option with the same semantics.
798+* A new tactic `claim N TY` that introduces a new hole named `N` with type `TY`
799+* A new tactic `unfocus` that moves the current hole to the bottom of the
801+* Quasiquotation supports the generation of `Language.Reflection.Raw` terms in
802+ addition to `Language.Reflection.TT`. Types are used for disambiguation,
803+ defaulting to `TT` at the REPL.
804+* `Language.Reflection.Quotable` now takes an extra type parameter which
805+ determines the type to be quoted to. Instances are provided to quote common
806+ types to both `TT` and `Raw`.
807+* Library operators have been renamed for consistency with Haskell. In
808+ particular, `Applicative.(<$>)` is now `Applicative.(<*>)` and `(<$>)` is now
809+ an alias for Functor.map. Correspondingly, ($>) and (<$) have been renamed to
810+ `(<*)` and `(*>)`. The cascading effects of this rename are that
811+ `Algebra.(<*>)` has been renamed to `Algebra.(<.>)` and `Matrix.(<.>)` is now
813+* Binding forms in DSL notation are now given an extra argument: a reflected
814+ representation of the name that the user chose. Specifically, the rewritten
815+ `lambda`, `pi`, and `let` binders will now get an extra argument of type
816+ `TTName`. This allows more understandable dynamic errors in DSL code and more
817+ readable code generation results.
818+* DSL notation can now be applied with `$`
819+* Added `FFI_Export` type which allows Idris functions to be exportoed and
820+ called from foreign code
821+* Instances can now have documentation strings.
822+* Type providers can have documentation strings.
823+* Unification errors now (where possible) contain information about provenance
825+* New REPL command `:core TM` that shows the elaborated form of `TM` along with
826+ its elaborated type using the syntax of `TT`. IDE mode has a corresponding
827+ command `:elaborate-term` for serialized terms.
828+* Effectful and IO function names for sending data to STDOUT have been
829+ aligned, semantically.
830+ + `print` is now for putting showable things to STDOUT.
831+ + `printLn` is for putting showable things to STDOUT with a new line
832+ + `putCharLn` for putting a single character to STDOUT, with a new line.
833+* Classes can now be annotated with 'determining parameters' to say which must
834+ be available before resolving instances. Only determining parameters are
835+ checked when checking for overlapping instances.
836+* New package `contrib` containing things that are less mature or less used than
837+ the contents of `base`. `contrib` is not available by default, so you may need
838+ to add `-p contrib` to your .ipkg file or Idris command line.
839+* Arguments to class instances are now checked for injectivity. Unification
840+ assumes this, so we need to check when instances are defined.
844+* Inductive-inductive definitions are now supported (i.e. simultaneously defined
845+ types where one is indexed by the other.)
846+* Implicits and type class constraints can now appear in scopes other than the
848+* Importing a module no longer means it is automatically reexported. A new
849+ `public` modifier has been added to import statements, which will reexport the
850+ names exported from that module.
851+* Implemented `@`-patterns. A pattern of the form `x@p` on the left hand side
852+ matches `p`, with `x` in scope on the right hand side with value `p`.
853+* A new tactic sourceLocation that fills the current hole with the current
854+ source code span, if this information is available. If not, it raises an
856+* Better Unicode support for the JavaScript/Node codegen
857+* `:search` and `:apropos` commands can now be given optional package lists to
859+* `Vect`, `Fin` and `So` moved out of prelude into `base`, in modules
860+ `Data.Vect`, `Data.Fin` and `Data.So` respectively.
861+* Several long-standing issues resolved, particularly with pattern matching and
863+* Modules can now have API documentation strings.
867+* Two new tactics: `skip` and `fail`. Skip does nothing, and fail takes a string
868+ as an argument and produces it as an error.
869+* Corresponding reflected tactics `Skip` and `Fail`. Reflected `Fail` takes a
870+ list of `ErrorReportParts` as an argument, like error handlers produce,
871+ allowing access to the pretty-printer.
872+* Stop showing irrelevant and inaccessible internal names in the interactive
874+* The proof arguments in the `List` library functions are now implicit and
875+ solved automatically.
876+* More efficient representation of proof state, leading to faster elaboration of
878+* *EXPERIMENTAL* Implementation of uniqueness types
879+* Unary negation now desugars to `negate`, which is a method of the `Neg` type
880+ class. This allows instances of `Num` that can't be negative, like `Nat`, and
881+ it makes correct IEEE Float operations easier to encode. Additionally, unary
882+ negation is now available to DSL authors.
883+* The Java and LLVM backends have been factored out for separate
884+ maintenance. Now, the compiler distribution only ships with the C and
885+ JavaScript backends.
886+* New REPL command `:printdef` displays the internal definition of a name
887+* New REPL command `:pprint` pretty-prints a definition or term with LaTeX or
889+* Naming of data and type constructors is made consistent across the standard
891+* Terms in `code blocks` inside of documentation strings are now parsed and type
892+ checked. If this succeeds, they are rendered in full color in documentation
893+ lookups, and with semantic highlighting for IDEs.
894+* Fenced code blocks in docs defined with the "example" attribute are rendered
896+* Fenced code blocks declared to be Idris code that fail to parse or type check
897+ now provide error messages to IDE clients.
898+* *EXPERIMENTAL* support for partial evaluation (Scrapping your Inefficient
903+* Tactic for case analysis in proofs
904+* Induction and case tactic now work on expressions
905+* Support for running tests for a package with the tests section of .ipkg files
906+ and the `--testpkg` command-line option
907+* Clearly distinguish between type providers and postulate providers at the use
909+* Allow dependent function syntax to be overridden in dsl blocks, similarly to
910+ functions and let. The keyword for this is `pi`.
911+* Updated `effects` library, with simplified API
912+* All new JavaScript backend (avoids callstack overflows)
913+* Add support for `%lib` directive for NodeJS
914+* Quasiquotes and quasiquote patterns allow easier work with reflected
915+ terms. `` `(EXPR)`` quasiquotes EXPR, causing the elaborator to be
916+ used to produce a reflected version of it. Subterms prefixed with `~`
917+ are unquoted - on the RHS, they are reflected terms to splice in,
918+ while on the LHS they are patterns.
920+ A quasiquote expression can be given a goal type for the elaborator,
921+ which helps with disambiguation. For instance, `` `(() : ())``
922+ quotes the unit constructor, while `` `(() : Type)`` quotes the unit
923+ type. Both goal types and quasiquote are typechecked in the global
925+* Better inference of unbound implicits
929+* IDE support for retrieving structured information about metavariables
930+* Experimental Bits support for JavaScript
931+* IdrisDoc: a Haddock- and JavaDoc-like HTML documentation generator
932+* Command line option `-e` (or `--eval`) to evaluate expressions without loading
933+ the REPL. This is useful for writing more portable tests.
934+* Many more of the basic functions and datatypes are documented.
935+* Primitive types such as Int and String are documented
936+* Removed javascript lib in favor of idris-hackers/iQuery
937+* Specify codegen for :compile REPL command (e.g. `:compile` javascript
939+* Remove `:info` REPL command, subsume and enhance its functionality in the `:doc` command
940+* New (first class) nested record update/access syntax:
943+ record { a->b->c = val } x -- sets field accessed by c (b (a x)) to val
944+ record { a->b->c } x -- accesses field, equivalent to c (b (a x))
947+* The banner at startup can be suppressed by adding `:set` nobanner to the initialisation script.
948+* `:apropos` now accepts space-delimited lists of query items, and searches for
949+ the conjunction of its inputs. It also accepts binder syntax as search
950+ strings - for instance, `->` finds functions.
951+* Totality errors are now treated as warnings until code generation time, when
952+ they become errors again. This allows users to use the interactive editing
953+ features to fix totality issues, but no programs that violate the stated
954+ assumptions will actually run.
955+* Added `:makelemma` command, which adds a new top level definition to solve a
957+* Extend `:addclause` to add instance bodies as well as definitions
958+* Reverse parameters to `BoundedList` -- now matches `Vect`, and is easier to
959+ instantiate classes.
960+* Move `foldl` into Foldable so it can be overridden.
961+* Experimental `:search` REPL command for finding functions by type
965+* New implementation of erasure
969+* Proof search now works for metavariables in types, giving some interactive
971+* New `Lazy` type, replacing laziness annotations.
972+* JavaScript and Node codegen now understand the `%include` directive.
973+* Concept of `null` is now understood in the JavaScript and Node codegen.
974+* Lots of performance patches for generated JavaScript.
975+* New commands `:eval` (`:e`) and `:type` (`:t`) in the prover, which either
976+ normalise or show the type of expressions.
977+* Allow type providers to return postulates in addition to terms.
978+* Syntax for dealing with match failure in `<-` and pattern matching let.
979+* New syntax for inline documentation. Documentation starts with `|||`, and
980+ arguments are documented by preceding their name with `@`. Example:
983+ ||| Add two natural numbers
984+ ||| @ n the first number (examined by the function)
985+ ||| @ m the second number (not examined)
986+ plus (n, m : Nat) -> Nat
989+* Allow the auto-solve behaviour in the prover to be disabled, for easier
990+ debugging of proof automation. Use `:set autosolve` and `:unset autosolve`.
991+* Updated `effects` library
992+* New `:apropos` command at REPL to search documentation, names, and types
993+* Unification errors are now slightly more informative
994+* Support mixed induction/coinduction with `Inf` type
995+* Add `covering` function option, which checks whether a function and all
996+ descendants cover all possible inputs
1000+* Agda-style equational reasoning (in Syntax.PreorderReasoning)
1001+* 'case' construct now abstracts over the scrutinee in its type
1002+* Added label type 'name (equivalent to the empty type). This is intended for
1003+ field/effect disambiguation. "name" can be any valid identifier. Two labels
1004+ are definitionally equal if they have the same name.
1005+* General improvements in error messages, especially %error_reverse annotation,
1006+ which allows a hint as to how to display a term in error messages
1007+* `--ideslave` mode now transmits semantic information about many of the strings
1008+ that it emits, which can be used by clients to implement semantic highlighting
1009+ like that of the REPL. This has been implemented in the Emacs mode and the IRC
1010+ bot, which can serve as examples.
1011+* New expression form: `with NAME EXPR` privileges the namespace `NAME` when
1012+ disambiguating overloaded names. For example, it is possible to write `with
1013+ Vect [1,2,3]` at the REPL instead of `the (Vect _ _) [1,2,3]`, because the
1014+ `Vect` constructors are defined in a namespace called `Vect`.
1015+* `assert_smaller` internal function, which marks an expression as smaller than
1016+ a pattern for use in totality checking. e.g. `assert_smaller (x :: xs) (f
1017+ xs)` asserts that `f xs` will always be structurally smaller than `(x :: xs)`
1018+* `assert_total` internal function, which marks a subexpression as assumed to be
1019+ total, e.g `assert_total (tail (x :: xs))`.
1020+* Terminal width is automatically detected if Idris is compiled with curses
1021+ support. If curses is not available, automatic mode assumes 80 columns.
1022+* Changed argument order for `Prelude.Either.either`.
1023+* Experimental `neweffects'`library, intended to replace `effects` in the next
1028+* Faster elaboration
1029+* Smaller .ibc files
1030+* Pretty-printer now used for all term output
1034+* Type classes now implemented as dependent records, meaning that method types
1035+ may now depend on earlier methods.
1036+* More flexible class instance resolution, so that function types and lambda
1037+ expressions can be made instances of a type class.
1038+* Add `!expr` notation for implicit binding of intermediate results in
1039+ monadic/do/etc expressions.
1040+* Extend Effects package to cope with possibly failing operations, using
1041+ `if_valid`, `if_error`, etc.
1042+* At the REPL, `it` now refers to the previous expression.
1043+* Semantic colouring at the REPL. Turn this off with `--nocolour`.
1044+* Some prettifying of error messages.
1045+* The contents of `~/.idris/repl/init` are run at REPL start-up.
1046+* The REPL stores a command history in `~/.idris/repl/history`.
1047+* The `[a..b]`, `[a,b..c]`, `[a..]`, and `[a,b..]` syntax now pass the totality
1048+ checker and can thus be used in types. The `[x..]` syntax now returns an
1049+ actually infinite stream.
1050+* Add `%reflection` option for functions, for compile-time operations on syntax.
1051+* Add expression form `quoteGoal x by p in e` which applies `p` to the expected
1052+ expression type and binds the result to `x` in the scope `e`.
1053+* Performance improvements in Strings library.
1054+* Library reorganisation, separated into `prelude/` and `base/`.
1058+* New module/dependency tree checking.
1059+* New parser implementation with more precise errors.
1060+* Improved type class resolution.
1061+* Compiling Nat via GMP integers.
1062+* Performance improvements in elaboration.
1063+* Improvements in termination checking.
1064+* Various REPL commands to support interactive editing, and a client/server
1065+ mode to allow external invocation of REPL commands.
1069+## User visible changes
1071+* Apply functions by return type, rather than with arguments: `t <== f` means
1072+ "apply f with arguments such that it returns a value of type t"
1073+* Allow the result type of a rewrite to be specified
1074+* Allow names to be attached to provisional definitions lhs `?= {name} rhs` --
1075+ generates a lemma called `name` which makes the types of the lhs and rhs
1076+ match. `{name}` is optional - a unique name is generated if it is absent.
1077+* Experimental LLVM backend
1078+* Added `Data.HVect` module
1079+* Fix `fromInteger` to take an `Integer`, rather than an `Int`
1080+* Integer literals for `Fin`
1081+* Renamed `O` to `Z`, and `fO` to `fZ`
1082+* Swapped `Vect` arguments, now `Vect : Nat -> Type -> Type`
1083+* Added `DecEq` instances
1084+* Add `equiv` tactic, which rewrites a goal to an equivalent (convertible) goal
1088+* Add annotation for unification traces
1089+* Add `mrefine` tactic for refining by matching against a type
1090+* Type class resolution fixes
1091+* Much faster coverage checking
1095+## User visible changes
1097+* Added `rewrite ... in ...` construct
1098+* Allow type class constraints in `using` clauses
1099+* Renamed `EFF` to `EFFECT` in Effect package
1100+* Experimental Java backend
1101+* Tab completion in REPL
1102+* Dynamic loading of C libraries in the interpreter
1103+* Testing IO actions at the REPL with `:x` command
1104+* Improve rendering of `:t`
1105+* Fixed some INTERNAL ERROR messages
1109+* Fix non-linear pattern checking
1110+* Improved name disambiguation
1111+* More flexible unification and elaboration of lambdas
1112+* Various unification and totality checking bug fixes
1116+## User visible changes
1118+* `implicit` keyword, for implicit type conversion
1119+* Added Effects package
1120+* Primitives for 8,16,32 and 64 bit integers
1124+* Change unification so that it keeps track of failed constraints in case
1125+ later information helps to resolve them
1126+* Distinguishing parameters and indices in data types
1127+* Faster termination/coverage checking
1128+* Split 'javascript' target into 'javascript' and 'node'
1132+## User visible changes
1134+* The type of types is now `Type` rather than `Set`
1135+* Forward declarations of data allowed
1136+ - supporting induction recursion and mutually recursive data
1137+* Type inference of definitions in `where` clauses
1138+ - Provided that the type can be completely determined from the first
1139+ application of the function (in the top level definition)
1140+* `mutual` blocks added
1141+ - effect is to elaborate all types of declarations in the block before
1142+ elaborating their definitions
1143+ - allows inductive-recursive definitions
1144+* Expression inspected by `with` clause now abstracted from the goal
1145+ - i.e. "magic" with
1146+* Implicit arguments will be added automatically only if their initial letter is
1147+ lower case, or they are in a using declaration
1148+* Added documentation comments (Haddock style) and `:doc` REPL command
1149+* Pattern matching on strings, big integers and characters
1150+* Added `System.Concurrency` modules
1151+* Added `postulate` declarations
1152+* Allow type annotations on `let` tactic
1153+* EXPERIMENTAL JavaScript generation, with `--target javascript` option
1157+* Separate inlining methods at compile-time and run-time
1158+* Fixed nested parameters blocks
1159+* Improve efficiency of elaborator by:
1160+ - only normalising when necessary
1161+ - reducing backtracking with resolving ambiguities
1162+* Better compilation of case trees
1166+## User visible changes
1169+ - as data declarations, but constructor arguments are evaluated lazily
1170+ - functions which return a codata type do not reduce at compile time
1171+* Added `parameters` blocks
1172+* Allow local data definitions in where blocks
1173+* Added `%default` directive to declare total-by-default or partial-by-default
1174+ for functions, and a corresponding "partial" reserved words to mark functions
1175+ as allowed to be partial. Also `--total` and `--partial` added as command line
1177+* Command line option `--warnpartial` for flagging all undeclared partial
1178+ functions, without error.
1179+* New termination checker supporting mutually recursive definitions.
1180+* Added `:load` command to REPL, for loading a new file
1181+* Added `:module` command to REPL, for adding modules
1182+* Renamed library modules (now have initial capital)
1186+* Several improvements and fixes to unification
1187+* Added collapsing optimisation and more aggressive erasure
1191+## User visible changes
1193+* Simple packaging system
1194+* Added `--dumpc` flag for displaying generated code
1198+* Improve overloading resolution (especially where this is a type error)
1199+* Various important bug fixes with evaluation and compilation
1200+* More aggressive compile-time evaluation
1204+## User visible changes
1206+* Added binding forms to syntax rules
1207+* Named class instances
1208+* Added `:set` command, with options `errorcontext` for displaying local
1209+ variables in scope when a unification error occurs, and `showimplicits`
1210+ for displaying elaborated terms in full
1211+* Added `--errorcontext` command line switch
1212+* Added `:proofs` and `:rmproofs` commands
1213+* Various minor REPL improvements and fixes
1217+* Completely new run time system (not based on Epic or relying on Boehm GC)
1218+* Normalise before forcing to catch more forceable arguments
1219+* Types no longer exported in normal form
1220+* Try to resolve overloading by inspecting types, rather than full type
1225+## User visible changes
1227+* backtick notation added: ``x `foo` y ==> foo x y``
1228+* case expressions allowed in type signatures
1229+* Library extensions in prelude.vect and prelude.algebra
1230+* `malloc`/`trace_malloc` added to builtins.idr
1234+* Some type class resolution fixes
1235+* Several minor bug fixes
1236+* Performance improvements in resolving overloading and type classes
1240+## User visible changes
1242+* DSL notation, for overloading lambda and let bindings
1243+* Dependent records, with projection and update
1244+* Totality checking and `total` keyword
1245+* Auto implicits and default argument values `{auto n : T}`, `{default val n : T}`
1246+* Overlapping type class instances disallowed
1247+* Many extensions to `prelude.nat` and `prelude.list` libraries (mostly thanks to
1249+* New libraries: `control.monad.identity`, `control.monad.state`
1250+* Small improvements in error reporting
1254+* Faster compilation (only compiling names which are used)
1255+* Better type class resolution
1256+* Lots of minor bug fixes
1262+## User visible changes
1264+* New proof/tactics syntax
1265+* New syntax for pairs/dependent pairs
1266+* Indentation-significant syntax
1267+* Added type classes
1268+* Added where clauses
1269+* Added case expressions, pattern matching let and lambda
1270+* Added monad comprehensions
1271+* Added cumulativity and universe checking
1272+* Ad-hoc name overloading
1273+ - Resolved by type or explicit namespace
1274+* Modules (Haskell-style)
1275+* public, abstract and private access to functions and types
1276+* Separate type-checking
1277+* Improved interactive environment
1278+* Replaced 'do using' with Monad class
1279+* Extended syntax macros
1284+* All definitions (functions, classes and instances) are elaborated to top
1285+ level, fully explicit, data declarations and pattern matching definitions,
1286+ which are verified by a minimal type checker.
1288+This is the first release of a complete reimplementation. There will be bugs.
1289+If you find any, please do not hesitate to contact Edwin Brady
1290+(ecb10@st-andrews.ac.uk).
@@ -0,0 +1,29 @@
3+If you use `Idris` in your work we would prefer it if you would use the following reference in your work.
9+ author = {BRADY,EDWIN},
10+ title = {Idris, a general-purpose dependently typed programming language: Design and implementation},
11+ journal = {Journal of Functional Programming},
19+ doi = {10.1017/S095679681300018X},
20+ URL = {https://journals.cambridge.org/article_S095679681300018X},
26+ EDWIN BRADY (2013). Idris, a general-purpose dependently typed
27+ programming language: Design and implementation. Journal of
28+ Functional Programming, 23, pp
29+ 552-593. doi:10.1017/S095679681300018X.
@@ -1,34 +1,79 @@
1# Contributing to Idris-Dev
1# Contributing to Idris-Dev
3The Idris Community welcomes pull requests, bug reporting, and bug squashing!
3The Idris Community welcomes pull requests, bug reporting, and bug squashing!
4−However, we cannot do it all ourself, and want to make it as easy as possible to contribute changes to get things working.
4+However, we cannot do it all ourselves, and want to make it as easy as possible to contribute changes to get things working.
5Here are a few guidelines that we would like contributors to follow so that we can have a chance of keeping on top of things.
5Here are a few guidelines that we would like contributors to follow so that we can have a chance of keeping on top of things.
7## Getting Started
7## Getting Started
9−1. Make sure you are familiar with [Git](http://git-scm.com/book).
9+1. Make sure you are familiar with [Git](https://git-scm.com/book).
101. Make sure you have a [GitHub account](https://github.com/signup/free).
101. Make sure you have a [GitHub account](https://github.com/signup/free).
11−1. Make sure you are familiar with: [Idris](http://eb.host.cs.st-andrews.ac.uk/writings/idris-tutorial.pdf).
11+1. Make sure you are familiar with: [Idris](https://eb.host.cs.st-andrews.ac.uk/writings/idris-tutorial.pdf).
12−1. Make sure you can install `Idris`:
12+1. Make sure you can install Idris:
13 * [Mac OS X](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-OS-X-using-Homebrew)
13 * [Mac OS X](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-OS-X-using-Homebrew)
14 * [Ubuntu](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-Ubuntu)
14 * [Ubuntu](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-Ubuntu)
15 * [Debian](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-Debian)
15 * [Debian](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-Debian)
16 * [Windows](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-Windows)
16 * [Windows](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-Windows)
18−# Issue Reporting
18+## Issue Reporting
20Before you report an issue, or wish to add cool functionality please try and check to see if there are existing [issues](https://github.com/idris-lang/Idris-dev/issues) and [pull requests](https://github.com/idris-lang/Idris-dev/pulls).
20Before you report an issue, or wish to add cool functionality please try and check to see if there are existing [issues](https://github.com/idris-lang/Idris-dev/issues) and [pull requests](https://github.com/idris-lang/Idris-dev/pulls).
21We do not want you wasting your time, duplicating somebody's work!
21We do not want you wasting your time, duplicating somebody's work!
24+Try as closely as possible to describe the issue, ensuring that it has sections that match the following headings:
25+> \# Steps to Reproduce
27+> \# Expected Behavior
29+> \# Observed Behavior
33+In addition, please attach complete source files that exhibit the issue to quoting from them in the issue.
36+We would be delighted to receive feature requests only if they are feasible to implement and the author is willing to implement the suggested features themself. The current Idris developer team consists mostly of volunteers, and so it is unfortunately hard to accommodate implementing nice-to-have ideas that are not essential for core language development.
23## The Campsite Rule
38## The Campsite Rule
25−A basic rule when contributing to Idris is the **campsite rule**: leave the codebase in better condition than you found it.
40+We try to follow the **campsite rule**: leave the code base in better condition than you found it.
26Please clean up any messes that you find, and don't leave behind new messes for the next contributor.
41Please clean up any messes that you find, and don't leave behind new messes for the next contributor.
43+## Contributing to the default libraries.
45+Idris ships with a set of packages in `libs/` that is provided as a default library.
47++ `prelude` is a collection of basic definitions, automatically imported by Idris programs.
48++ `base` is tried and tested code that may be useful, and has seen active use in multiple projects.
49++ `contrib` is code that is experimental in design and that we want to test before possible inclusion in `base`.
50++ `effects` is a library which supports effectful programming.
52+These packages should not be seen as the *standard* as when working with dependent types; we do not necessarily know how best to work with dependent types yet.
53+These packages offer functionality that can be built on top of when constructing Idris programs.
55+Everything in prelude will be imported automatically, unless given the `--noprelude` option.
56+The contents of base are available with no special options, but modules must be imported.
57+The other two packages that ship with Idris, contrib and effects, require the use of the `-p` command-line argument to bring their contents into the include path.
59+New contributions should be added to the contrib package (never directly to base or prelude!).
60+If they turn out to be widely applicable and useful, they may later be moved into base.
62+As Idris is still being developed we are open to suggestions and changes that make improvements to these default packages.
63+Major changes to the library, or Idris itself, should be discussed first through the project's official channels of communication:
66+1. On our IRC Channel `#idris` on freenode, or
67+1. As an RFC in the issue tracker
69+Developers then seeking to add content to Idris's prelude and default library, should do so through a PR where more discussions and refinements can be made.
71+We do not want you wasting your time nor duplicating somebody's work!
28## Making Changes
73## Making Changes
30−Idris developers and hackers try to adhere to something similar to the [successful git branching model](http://nvie.com/posts/a-successful-git-branching-model/).
75+Idris developers and hackers try to adhere to something similar to the [successful git branching model](https://nvie.com/posts/a-successful-git-branching-model/).
31−The steps are straightforward.
76+The steps are described below.
33### New contributors
78### New contributors
@@ -38,7 +83,7 @@ For those new to the project:
382. Clone your fork to your local machine:
832. Clone your fork to your local machine:
41−$ git clone git@github.com/<your github user name>/Idris-dev.git
86+$ git clone git@github.com:<your github user name>/Idris-dev.git
443. Add `idris-lang/Idris-dev` as a remote upstream
893. Add `idris-lang/Idris-dev` as a remote upstream
@@ -64,7 +109,7 @@ The remaining steps are the same for both new and existing contributors:
651. Create, and checkout onto, a topic branch on which to base you work.
1101. Create, and checkout onto, a topic branch on which to base you work.
66 * This is typically the master branch.
111 * This is typically the master branch.
67− * For your own sanity, please avoid working on the `master` branch.
112+ * Please avoid working on the `master` branch.
70$ git branch fix/master/my_contrib master
115$ git branch fix/master/my_contrib master
@@ -88,16 +133,16 @@ $ git diff --check
88 line separating the summary from the body is critical (unless you omit
133 line separating the summary from the body is critical (unless you omit
89 the body entirely); tools like rebase can get confused if you run the
134 the body entirely); tools like rebase can get confused if you run the
90 two together.
135 two together.
92 Further paragraphs come after blank lines.
137 Further paragraphs come after blank lines.
94 - Bullet points are okay, too
139 - Bullet points are okay, too
96 - Typically a hyphen or asterisk is used for the bullet, preceded by a
141 - Typically a hyphen or asterisk is used for the bullet, preceded by a
97 single space, with blank lines in between, but conventions vary here
142 single space, with blank lines in between, but conventions vary here
991. Make sure you have added any necessary tests for your changes.
1441. Make sure you have added any necessary tests for your changes.
100−1. Run all the tests to assure nothing else was accidentally broken.
145+1. Run all the tests to ensure nothing else was accidentally broken.
103$ make test
148$ make test
@@ -115,27 +160,25 @@ From there you will have to wait on one of the `idris-dev` committers to respond
115This response might be an accept or some changes/improvements/alternatives will be suggest.
160This response might be an accept or some changes/improvements/alternatives will be suggest.
116We do not guarantee that all requests will be accepted.
161We do not guarantee that all requests will be accepted.
118−## Increases chances of acceptance.
163+## Increasing chances of acceptance.
120To help increase the chance of your pull request being accepted:
165To help increase the chance of your pull request being accepted:
1221. Run the tests.
1671. Run the tests.
123−1. Update the documentation, the surrounding one, examples elsewhere, guides, whatever is affected by your contribution
168+1. Update the documentation, the surrounding code, examples elsewhere, guides, whatever is affected by your contribution
124−1. Use appropriate code formatting for both `Idris` and `Haskell`.
169+1. Use appropriate code formatting for both Idris and Haskell.
126## Additional Resources
171## Additional Resources
128* [Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki);
173* [Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki);
129* [Zen Of Idris](https://github.com/idris-lang/Idris-dev/wiki/The-Zen-of-Idris);
174* [Zen Of Idris](https://github.com/idris-lang/Idris-dev/wiki/The-Zen-of-Idris);
130−* Idris FAQs: [Official](http://www.idris-lang.org/documentation/faq/); [Unofficial](https://github.com/idris-lang/Idris-dev/wiki/Unofficial-FAQ);
175+* Idris FAQs: [Official](https://idris.readthedocs.io/en/latest/faq/faq.html); [Unofficial](https://github.com/idris-lang/Idris-dev/wiki/Unofficial-FAQ);
131* [Idris Manual](https://github.com/idris-lang/Idris-dev/wiki/Manual);
176* [Idris Manual](https://github.com/idris-lang/Idris-dev/wiki/Manual);
132−* [Idris Tutorial](http://eb.host.cs.st-andrews.ac.uk/writings/idris-tutorial.pdf);
177+* [Idris Tutorial](https://idris.readthedocs.io/en/latest/tutorial/index.html);
133−* [Idris News](http://www.idris-lang.org/news/);
178+* [Idris News](https://www.idris-lang.org/news/);
134−* [other Idris docs](http://www.idris-lang.org/documentation/).
179+* [other Idris docs](https://www.idris-lang.org/documentation/).
135* [Using Pull Requests](https://help.github.com/articles/using-pull-requests)
180* [Using Pull Requests](https://help.github.com/articles/using-pull-requests)
136* [General GitHub Documentation](https://help.github.com/).
181* [General GitHub Documentation](https://help.github.com/).
139−Adapted from the most excellent contributing files from the [Puppet project](https://github.com/puppetlabs/puppet) and [Factroy Girl Rails](https://github.com/thoughtbot/factory_girl_rails/blob/master/CONTRIBUTING.md)
184+Adapted from the most excellent contributing files from the [Puppet project](https://github.com/puppetlabs/puppet) and [Factory Girl Rails](https://github.com/thoughtbot/factory_girl_rails/blob/master/CONTRIBUTING.md)
@@ -1,31 +1,229 @@
1Thanks to the following for their help and contributions:
1Thanks to the following for their help and contributions:
4Ahmad Salim Al-Sibahi
8Ahmad Salim Al-Sibahi
5−Edward Chadwick Amsden
9+Aistis Raulinaitis
6−Nicola Botta
10+Alex Feldman-Crough
7−Edwin Brady
11+Alex S. Queiroz e Silva
8−David Raymond Christiansen
12+Alexander Berntsen
9−Jason Dagit
13+Alexander Shabalin
10−Simon Fowler
14+Alyssa Carter
23+Apostolis Xekoukoulotakis
41+Casper M. H. Holmgreen
11Cezar Ionescu
43Cezar Ionescu
60+David Raymond Christiansen
12Irene Knapp
102Irene Knapp
107+Jan de Muijnck-Hughes
13Mathnerd314
147Mathnerd314
14−Hannes Mehnert
148+Mattias Lundell
15Mekeor Melire
152Mekeor Melire
16Melissa Mozifian
153Melissa Mozifian
17−Dominic Mulligan
154+Melvar Chen
18−Jan de Muijnck-Hughes
155+Michael A. Smith
20−Tom Prince
182+Reynir Björnsson
193+Sebastian de Bellefon
21Seo Sanghyeon
195Seo Sanghyeon
22−Benjamin Saunders
196+Sergei Trofimovich
23−startling
197+Shane Pearman
216+Timo Petteri Sinnemäki
@@ -0,0 +1,153 @@
1+# Idris Installation Guide
3+Copyright (C) 2015, The Idris Community
5+## Installing Idris from Hackage
7+This repository represents the latest development version of the
8+language, and may contain bugs that are being actively worked on. For
9+those who wish to use a more stable version of Idris please consider
10+installing the latest version that has been released on Hackage.
11+Installation instructions for various platforms can be
12+[found on the Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki/Installation-Instructions).
14+## Installing Development Versions
16+If you like to work against the latest development version, please
17+consider using Cabal Sandboxes to minimise disruption to your local
18+Haskell setup. Instructions for installing Idris HEAD within a cabal
20+[available on the Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki/Installing-an-Idris-Development-version-in-a-sandbox).
22+To configure, edit config.mk. The default values should work for most
25+Idris is built using a Makefile common targets include:
27+* `make` This will install everything using cabal and typecheck the
29+* `make test` This target execute the test suite.
30+* `make relib` This target will typecheck and recompile the standard
33+Idris has an optional dependency on the `C` library `libffi`. If you
34+would like to use the features that it enables, make sure that it is
35+compiled for the same architecture as your Haskell compiler (e.g. 64
36+bit libraries for 64 bit ghc). By default, Idris builds without it. To
37+build with it, pass the flag `-f FFI`.
39+A secondary optional dependency is on `libGMP`, this allows better
40+support for numeric operations. As with `libFFI` Idris builds with out
41+it, to enable `GMP` support use the flag `-f GMP`
43+To build with `libffi` and `libGMP` by default, create a `custom.mk`
44+file and add the following line to it:
46+`CABALFLAGS += -f FFI -f GMP`
48+The file `custom.mk-alldeps` is a suitable example.
50+The continuous integration builds on travis-ci.org are built using the
51+ghc-flag -Werror. To enable this behaviour locally also, please
52+compile using `make CI=true` or adding the following line into
57+If you are only compiling for installing the most current version, you
58+can omit the CI flag, but please make sure you use it if you want to
61+## Experimental Support for Building with Stack
63+[Stack](https://github.com/commercialhaskell/stack) is a new
64+cross-platform program for developing Haskell projects, that enhances
65+the functionality provided by Cabal. There is experimental support for
66+building Idris from source with stack.
68+This installation has been tested on Ubuntu 16.04.1 LTS, and the current
71+*Important* Stack will not install any external dependencies required
72+to build Idris. Before you try stack please ensure you have the
75+To build Idris with stack use the following command:
83+Stack will install Idris (and related executables) into `$HOME/.local/bin/`
84+on Unix based systems and an appropriate place on Windows. The libraries that
85+are included with Idris (e.g. Builtins, Prelude) will 'install' into `<source
86+dir>/.stack_work/install/...` so you'll need to keep your source directory
87+around after you've installed Idris using Stack.
89+Of note: If you haven't used stack before commands will also setup the
90+related infrastructure. For more information about Stack please visit
91+the [Stack website](https://github.com/commercialhaskell/stack).
93+On NixOS, please use the following command instead, to make sure
94+the required libraries and header files are available:
98+### before rebuilding new pulls
99+the default build will currently just reuse `.ibc` files which can result
100+in build-failures in the `Building libraries...` phase.
102+A safer way to do this is therefore to recursively delete all the `*.ibc`
103+files from the `libs/` folder.
105+On Linux(or similar) you can do this with
107+ find . -name "*.ibc" -exec rm -rf {} \;
111+The flag `--system-ghc` can be added to enforce use of your system's
114+### `libGMP` and `libFFI`
116+By default the stack configuration in `stack.yaml` will build with
117+support for `libGMP` and `libFFI`. To turn this support off, the
118+option flags needs to be fully commented out.
120+There have been reports in the past over building Idris on Mac OS X,
121+using stack, and linking to a HomeBrew installation of `libFFI`. The
122+build has failed to find the correct `libFFI` installation. If you
123+encounter this then the fix is to augment the `PKG_CONFIG_PATH` for
124+`libFFI`. For example:
127+PKG_CONFIG_PATH=/usr/local/opt/libffi/lib/pkgconfig stack build
130+## Issue with GHC on Ubuntu/Fedora
132+There is an upstream issue with GHC on some Ubuntu and Fedora machines.
133+The issue is that for GHC versions greater than 8.4.X linking to libFFI uses the version of libFFI shipped with GHC, instead of the system version.
135+See the following GHC issue page for more information:
137+ <https://gitlab.haskell.org/ghc/ghc/issues/15397>
139+This means that an Idris built with `libFFI` support will fail at runtime as the executable would not be able to find the correct `libffi` shared object.
140+This will cause the build to fail.
141+Specifically, one will see an error message along the lines of:
143+> error while loading shared libraries: libffi.so.7: cannot open shared object file: No such file or directory
145+A workround for this bug is to override the used libffi version (this is what we use on CI):
148+export LD_PRELOAD=/opt/ghc/${GHCVER}/lib/ghc-${GHCVER}/rts/libffi.so.7
153+For reasons that haven't been investigated building the Idris compiler with GHC 8.6 leads to a compiler which doesn't pass test.
@@ -1,50 +1,82 @@
1−.PHONY: build configure doc install linecount nodefault pinstall lib_clean relib test_c test
1+.PHONY: build configure doc install linecount nodefault pinstall lib_clean relib fast test_js test_c stylize test test_clean lib_doc lib_doc_clean user_doc_html user_doc_pdf user_docs
3include config.mk
7include config.mk
4-include custom.mk
8-include custom.mk
13+TEST-ARGS += --color always
7− $(CABAL) install $(CABALFLAGS)
18+ $(CABAL) v1-install $(CABALFLAGS)
9pinstall: CABALFLAGS += --enable-executable-profiling
20pinstall: CABALFLAGS += --enable-executable-profiling
10pinstall: dist/setup-config
21pinstall: dist/setup-config
11− $(CABAL) install $(CABALFLAGS)
22+ $(CABAL) v1-install $(CABALFLAGS)
13build: dist/setup-config
24build: dist/setup-config
14− $(CABAL) build $(CABALFLAGS)
25+ $(CABAL) v1-build $(CABALFLAGS)
18−test_c:
27+test: doc test_c stylize
19− $(MAKE) -C test IDRIS=../dist/build/idris
22− $(MAKE) -C test IDRIS=../dist/build/idris test_java
30+ ./stylize.sh
25− $(MAKE) -C test IDRIS=../dist/build/idris test_llvm
33+ $(CABAL) v1-test $(ARGS) --test-options \
34+ "$(TEST-ARGS) --rerun-update +RTS -N$(TEST-JOBS) -RTS"
28− $(MAKE) -C test IDRIS=../dist/build/idris test_js
37+ $(CABAL) v1-test $(ARGS) --test-options \
38+ "$(TEST-ARGS) --node --rerun-update +RTS -N$(TEST-JOBS) -RTS"
41+ $(CABAL) v1-test $(ARGS) --test-options \
42+ "$(TEST-ARGS) --accept +RTS -N$(TEST-JOBS) -RTS"
30−test_all:
44+test_clean:
31− $(MAKE) test
45+ rm -f test/*~
32− $(MAKE) test_llvm
46+ rm -f test/*/output
36 $(MAKE) -C libs IDRIS=../../dist/build/idris/idris RTS=../../dist/build/rts/libidris_rts clean
49 $(MAKE) -C libs IDRIS=../../dist/build/idris/idris RTS=../../dist/build/rts/libidris_rts clean
38relib: lib_clean
51relib: lib_clean
39− $(CABAL) install $(CABALFLAGS)
52+ $(CABAL) v1-install $(CABALFLAGS)
42− wc -l src/Idris/*.hs src/Core/*.hs src/IRTS/*.hs src/Pkg/*.hs
55+ wc -l src/Idris/*.hs src/Idris/Elab/*.hs src/Idris/Core/*.hs src/IRTS/*.hs src/Pkg/*.hs src/Util/*.hs
44#Note: this doesn't yet link to Hackage properly
57#Note: this doesn't yet link to Hackage properly
45doc: dist/setup-config
58doc: dist/setup-config
46− $(CABAL) haddock --executables --hyperlink-source --html --hoogle --html-location="http://hackage.haskell.org/packages/archive/\$$pkg/latest/doc/html" --haddock-options="--title Idris"
59+ $(CABAL) v1-haddock --hyperlink-source --html --hoogle --html-location="https://hackage.haskell.org/packages/archive/\$$pkg/latest/doc/html" --haddock-options="--title Idris"
62+ $(MAKE) -C libs IDRIS=../../dist/build/idris/idris doc
65+ $(MAKE) -C libs IDRIS=../../dist/build/idris/idris doc_clean
67+user_docs: user_doc_html user_doc_pdf
70+ $(MAKE) -C docs clean
76+ $(MAKE) -C docs latexpdf
79+ $(CABAL) v1-install $(CABALFLAGS) --ghc-option=-O0
49dist/setup-config:
81dist/setup-config:
50− $(CABAL) configure $(CABALFLAGS)
82+ $(CABAL) v1-configure $(CABALFLAGS)
@@ -1,20 +0,0 @@
1−Idris (http://idris-lang.org/) is an experimental functional programming
2−language with dependent types.
4−To configure, edit config.mk. The default values should work for most people.
6−To install, type 'make'. This will install everything using cabal and
7−typecheck the libraries.
9−To run the tests, type 'make test' which will execute the test suite, and
10−'make relib', which will typecheck and recompile the standard library.
12−Idris has optional buildtime dependencies on the C libraries llvm-3.3 and libffi. If you would like to use the features that these enable, be sure these are compiled for the same architecture as your Haskell compiler (e.g. 64 bit libraries for 64 bit ghc). By default, Idris builds without them. To build with them, pass the flags -f LLVM and -f FFI, respectively.
14−To build with LLVM and libffi by default, create custom.mk or add the following line to it:
15−CABALFLAGS += -f LLVM -f FFI
16−The file custom.mk-alldeps is a suitable example.
18−Idris has a runtime dependency on libgmp, and on Boehm GC (libgc) when using the LLVM codegen. These are needed for linking into compiled programs, so be sure these are compiled for Idris's default target architecture (usually 64 bit on x86_64 systems).
20−The Idris wiki contains instructions for building on various platforms and for getting involved with development. It is located at https://github.com/idris-lang/Idris-dev/wiki .
@@ -0,0 +1,49 @@
3+[](https://travis-ci.org/idris-lang/Idris-dev)
4+[](https://ci.appveyor.com/project/idrislang/idris-dev)
5+[](https://readthedocs.org/projects/idris/?badge=latest)
6+[](https://hackage.haskell.org/package/idris)
7+[](https://stackage.org/lts/package/idris)
8+[](https://stackage.org/nightly/package/idris)
9+[](https://www.irccloud.com/invite?channel=%23idris&hostname=irc.freenode.net&port=6697&ssl=1)
11+Idris (https://idris-lang.org/) is a general-purpose functional programming
12+language with dependent types.
14+## Installation Guides.
16+This repository represents the latest development version of the
17+language, and may contain bugs that are being actively worked on. For
18+those who wish to use a more stable version of Idris please consider
19+installing the latest version that has been released on Hackage.
20+Installation instructions for various platforms can be
21+[found on the Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki/Installation-Instructions).
23+More information about building Idris from source has been detailed in the [Installation Guide](INSTALL.md)
27+Idris has support for external code generators. Supplied with the distribution
28+is a C code generator to compile executables, and a JavaScript code generator
29+with support for node.js and browser JavaScript.
31+More information about [code generators can be found on the wiki](https://idris.readthedocs.io/en/latest/reference/codegen.html).
35+If you would like to find out more information, or ask questions, we
36+currently have a [Wiki](https://github.com/idris-lang/Idris-dev/wiki);
37+a [mailing list](https://groups.google.com/forum/#!forum/idris-lang),
38+and an `IRC` channel `#idris` on freenode. To join the IRC channel,
39+point your irc client to `chat.freenode.net` then `/join #idris`.
41+For those further interested in using Idris for projects, the
42+[Idris Hackers](https://github.com/idris-hackers) GitHub organisation is
43+where some interesting projects are being hosted.
45+For those interested in contributing to Idris directly we kindly ask that
46+prospective developers please consult the [Contributing Guide](CONTRIBUTING.md) first.
48+[Idris 2](https://github.com/edwinb/Idris2) is an early preview of the next generation
49+of Idris, implemented in Idris.
RELEASE-CHECKS.mdnew file+44
@@ -0,0 +1,44 @@
3+Things to be checked, or done before a release is made.
7++ [ ] Do the tests run to completion?
8++ [ ] Can samples build?
9++ [ ] Is `man/idris.1` up-to-date?
15++ [ ] `docs/listing/idris-prompt-helloworld.txt`.
16++ [ ] `docs/listing/idris-prompt-interp.txt`.
17++ [ ] `docs/listing/idris-prompt-start.txt`.
22++ [ ] Finalise and check `CHANGELOG.md`.
23++ [ ] Tag the release.
28++ [ ] Upload to Hackage.
29++ [ ] Upload package documentation to web site
33++ [ ] Generate Mac OS X Package.
34++ [ ] Prompt helpers to create:
35+ + [ ] Windows Binary.
36+ + [ ] HomeBrew Package.
41+ + [ ] Update web site with SHA256 hash of binary
42++ [ ] Email Mailing list.
43++ [ ] Make REDDIT post.
@@ -1,25 +1,36 @@
1{-# LANGUAGE CPP #-}
1{-# LANGUAGE CPP #-}
3+#if !defined(MIN_VERSION_Cabal)
4+# define MIN_VERSION_Cabal(x,y,z) 0
2import Control.Monad
7import Control.Monad
3import Data.IORef
8import Data.IORef
4import Control.Exception (SomeException, catch)
9import Control.Exception (SomeException, catch)
6import Distribution.Simple
11import Distribution.Simple
7−import Distribution.Simple.BuildPaths (autogenModulesDir)
12+import Distribution.Simple.BuildPaths
8import Distribution.Simple.InstallDirs as I
13import Distribution.Simple.InstallDirs as I
9import Distribution.Simple.LocalBuildInfo as L
14import Distribution.Simple.LocalBuildInfo as L
10import qualified Distribution.Simple.Setup as S
15import qualified Distribution.Simple.Setup as S
11import qualified Distribution.Simple.Program as P
16import qualified Distribution.Simple.Program as P
12−import Distribution.Simple.Utils (createDirectoryIfMissingVerbose, rewriteFile)
17+import Distribution.Simple.Utils
18+import Distribution.Compiler
13import Distribution.PackageDescription
19import Distribution.PackageDescription
14import Distribution.Text
20import Distribution.Text
21+import Distribution.Verbosity
23+import System.Environment
16import System.Exit
24import System.Exit
17−import System.FilePath ((</>), splitDirectories)
25+import System.FilePath ((</>), splitDirectories,isAbsolute)
18import System.Directory
26import System.Directory
19import qualified System.FilePath.Posix as Px
27import qualified System.FilePath.Posix as Px
20import System.Process
28import System.Process
21−import qualified Data.Text as T
29+
22−import qualified Data.Text.IO as TIO
30+#if (MIN_VERSION_Cabal(2,0,0))
31+import Distribution.Types.UnqualComponentName
24-- After Idris is built, we need to check and install the prelude and other libs
35-- After Idris is built, we need to check and install the prelude and other libs
@@ -38,7 +49,8 @@ idrisCmd local = ".." </> ".." </> buildDir local </> "idris" </> "idris"
38-- Make Commands
49-- Make Commands
40-- use GNU make on FreeBSD
51-- use GNU make on FreeBSD
41−#if defined(freebsd_HOST_OS) || defined(dragonfly_HOST_OS)
52+#if defined(freebsd_HOST_OS) || defined(dragonfly_HOST_OS)\
53+ || defined(openbsd_HOST_OS) || defined(netbsd_HOST_OS)
42mymake = "gmake"
54mymake = "gmake"
44mymake = "make"
56mymake = "make"
@@ -46,47 +58,61 @@ mymake = "make"
46make verbosity =
58make verbosity =
47 P.runProgramInvocation verbosity . P.simpleProgramInvocation mymake
59 P.runProgramInvocation verbosity . P.simpleProgramInvocation mymake
61+#ifdef mingw32_HOST_OS
62+windres verbosity = P.runProgramInvocation verbosity . P.simpleProgramInvocation "windres"
49-- -----------------------------------------------------------------------------
64-- -----------------------------------------------------------------------------
52−usesLLVM :: S.ConfigFlags -> Bool
67+usesGMP :: S.ConfigFlags -> Bool
53−usesLLVM flags =
68+usesGMP flags =
54− case lookup (FlagName "llvm") (S.configConfigurationsFlags flags) of
69+ case lookupFlagAssignment (mkFlagName "gmp") (S.configConfigurationsFlags flags) of
55 Just True -> True
70 Just True -> True
56 Just False -> False
71 Just False -> False
57− Nothing -> True
72+ Nothing -> False
59−usesGMP :: S.ConfigFlags -> Bool
74+execOnly :: S.ConfigFlags -> Bool
60−usesGMP flags =
75+execOnly flags =
61− case lookup (FlagName "gmp") (S.configConfigurationsFlags flags) of
76+ case lookupFlagAssignment (mkFlagName "execonly") (S.configConfigurationsFlags flags) of
62 Just True -> True
77 Just True -> True
63 Just False -> False
78 Just False -> False
64− Nothing -> True
79+ Nothing -> False
66isRelease :: S.ConfigFlags -> Bool
81isRelease :: S.ConfigFlags -> Bool
67isRelease flags =
82isRelease flags =
68− case lookup (FlagName "release") (S.configConfigurationsFlags flags) of
83+ case lookupFlagAssignment (mkFlagName "release") (S.configConfigurationsFlags flags) of
69 Just True -> True
84 Just True -> True
70 Just False -> False
85 Just False -> False
71 Nothing -> False
86 Nothing -> False
88+isFreestanding :: S.ConfigFlags -> Bool
89+isFreestanding flags =
90+ case lookupFlagAssignment (mkFlagName "freestanding") (S.configConfigurationsFlags flags) of
95+#if !(MIN_VERSION_Cabal(2,0,0))
96+mkFlagName :: String -> FlagName
100+#if !(MIN_VERSION_Cabal(2,2,0))
101+lookupFlagAssignment :: FlagName -> FlagAssignment -> Maybe Bool
102+lookupFlagAssignment = lookup
73-- -----------------------------------------------------------------------------
105-- -----------------------------------------------------------------------------
76−idrisClean _ flags _ _ = do
108+idrisClean _ flags _ _ = cleanStdLib
80 verbosity = S.fromFlag $ S.cleanVerbosity flags
110 verbosity = S.fromFlag $ S.cleanVerbosity flags
83− makeClean "libs"
112+ cleanStdLib = makeClean "libs"
85− cleanLLVM = makeClean "llvm"
87 makeClean dir = make verbosity [ "-C", dir, "clean", "IDRIS=idris" ]
114 makeClean dir = make verbosity [ "-C", dir, "clean", "IDRIS=idris" ]
90-- -----------------------------------------------------------------------------
116-- -----------------------------------------------------------------------------
91-- Configure
117-- Configure
@@ -95,26 +121,87 @@ gitHash = do h <- Control.Exception.catch (readProcess "git" ["rev-parse", "--sh
95 (\e -> let e' = (e :: SomeException) in return "PRE")
121 (\e -> let e' = (e :: SomeException) in return "PRE")
96 return $ takeWhile (/= '\n') h
122 return $ takeWhile (/= '\n') h
124+-- Generate a module that contains extra library directories passed
125+-- via command-line to cabal
126+generateBuildFlagsModule :: Verbosity -> FilePath -> [String] -> IO ()
127+generateBuildFlagsModule verbosity dir libdirs = do
128+ let buildFlagsModulePath = dir </> "BuildFlags_idris" Px.<.> "hs"
129+ putStrLn $ "Generating " ++ buildFlagsModulePath
130+ createDirectoryIfMissingVerbose verbosity True dir
131+ rewriteFileEx verbosity buildFlagsModulePath contents
132+ where contents = "module BuildFlags_idris where \n\n" ++
133+ "extraLibDirs :: [String]\n" ++
134+ "extraLibDirs = " ++ show libdirs
98-- Put the Git hash into a module for use in the program
136-- Put the Git hash into a module for use in the program
99-- For release builds, just put the empty string in the module
137-- For release builds, just put the empty string in the module
100generateVersionModule verbosity dir release = do
138generateVersionModule verbosity dir release = do
101− hash <- gitHash
139+ hash <- gitHash
102− let versionModulePath = dir </> "Version_idris" Px.<.> "hs"
140+ let versionModulePath = dir </> "Version_idris" Px.<.> "hs"
103− putStrLn $ "Generating " ++ versionModulePath ++
141+ putStrLn $ "Generating " ++ versionModulePath ++
104− if release then " for release" else (" for prerelease " ++ hash)
142+ if release then " for release" else " for prerelease " ++ hash
105− createDirectoryIfMissingVerbose verbosity True dir
143+ createDirectoryIfMissingVerbose verbosity True dir
106− rewriteFile versionModulePath (versionModuleContents hash)
144+ rewriteFileEx verbosity versionModulePath (versionModuleContents hash)
108 where versionModuleContents h = "module Version_idris where\n\n" ++
146 where versionModuleContents h = "module Version_idris where\n\n" ++
109 "gitHash :: String\n" ++
147 "gitHash :: String\n" ++
110 if release
148 if release
111 then "gitHash = \"\"\n"
149 then "gitHash = \"\"\n"
112− else "gitHash = \"-git:" ++ h ++ "\"\n"
150+ else "gitHash = \"git:" ++ h ++ "\"\n"
152+-- Generate a module that contains the lib path for a freestanding Idris
153+generateTargetModule verbosity dir targetDir = do
154+ let absPath = isAbsolute targetDir
155+ let targetModulePath = dir </> "Target_idris" Px.<.> "hs"
156+ putStrLn $ "Generating " ++ targetModulePath
157+ createDirectoryIfMissingVerbose verbosity True dir
158+ rewriteFileEx verbosity targetModulePath (versionModuleContents absPath targetDir)
159+ where versionModuleContents absolute td = "module Target_idris where\n\n" ++
160+ "import System.FilePath\n" ++
161+ "import System.Environment\n" ++
162+ "getDataDir :: IO String\n" ++
164+ then "getDataDir = return \"" ++ td ++ "\"\n"
165+ else "getDataDir = do \n" ++
166+ " expath <- getExecutablePath\n" ++
167+ " execDir <- return $ dropFileName expath\n" ++
168+ " return $ execDir ++ \"" ++ td ++ "\"\n"
169+ ++ "getDataFileName :: FilePath -> IO FilePath\n"
170+ ++ "getDataFileName name = do\n"
171+ ++ " dir <- getDataDir\n"
172+ ++ " return (dir ++ \"/\" ++ name)"
174+-- a module that has info about existence and location of a bundled toolchain
175+generateToolchainModule verbosity srcDir toolDir = do
176+ let commonContent = "module Tools_idris where\n\n"
177+ let toolContent = case toolDir of
178+ Just dir -> "hasBundledToolchain = True\n" ++
179+ "getToolchainDir = \"" ++ dir ++ "\"\n"
180+ Nothing -> "hasBundledToolchain = False\n" ++
181+ "getToolchainDir = \"\""
182+ let toolPath = srcDir </> "Tools_idris" Px.<.> "hs"
183+ createDirectoryIfMissingVerbose verbosity True srcDir
184+ rewriteFileEx verbosity toolPath (commonContent ++ toolContent)
114−idrisConfigure _ flags _ local = do
186+idrisConfigure _ flags pkgdesc local = do
115− configureRTS
187+ configureRTS
188+ withLibLBI pkgdesc local $ \lib libcfg -> do
189+ let libAutogenDir = autogenComponentModulesDir local libcfg
190+ let libDirs = extraLibDirs $ libBuildInfo lib
191+ generateBuildFlagsModule verbosity libAutogenDir libDirs
116− generateVersionModule verbosity (autogenModulesDir local) (isRelease (configFlags local))
192+ generateVersionModule verbosity libAutogenDir (isRelease (configFlags local))
193+ if isFreestanding $ configFlags local
195+ toolDir <- lookupEnv "IDRIS_TOOLCHAIN_DIR"
196+ generateToolchainModule verbosity libAutogenDir toolDir
197+ targetDir <- lookupEnv "IDRIS_LIB_DIR"
199+ Just d -> generateTargetModule verbosity libAutogenDir d
200+ Nothing -> error $ "Trying to build freestanding without a target directory."
201+ ++ " Set it by defining IDRIS_LIB_DIR."
203+ generateToolchainModule verbosity libAutogenDir Nothing
118 verbosity = S.fromFlag $ S.configVerbosity flags
205 verbosity = S.fromFlag $ S.configVerbosity flags
119 version = pkgVersion . package $ localPkgDescr local
206 version = pkgVersion . package $ localPkgDescr local
@@ -124,18 +211,14 @@ idrisConfigure _ flags _ local = do
124 -- the file after configure.
211 -- the file after configure.
125 configureRTS = make verbosity ["-C", "rts", "clean"]
212 configureRTS = make verbosity ["-C", "rts", "clean"]
127−idrisPreSDist args flags = do
214+#if !(MIN_VERSION_Cabal(2,0,0))
128− let dir = S.fromFlag (S.sDistDirectory flags)
215+ autogenComponentModulesDir lbi _ = autogenModulesDir lbi
129− let verb = S.fromFlag (S.sDistVerbosity flags)
216+#endif
130− generateVersionModule verb ("src") True
131− preSDist simpleUserHooks args flags
133−idrisPostSDist args flags desc lbi = do
218+#if !(MIN_VERSION_Cabal(2,0,0))
134− Control.Exception.catch (do let file = "src" </> "Version_idris" Px.<.> "hs"
219+rewriteFileEx :: Verbosity -> FilePath -> String -> IO ()
135− putStrLn $ "Removing generated module " ++ file
220+rewriteFileEx _ = rewriteFile
136− removeFile file)
221+#endif
137− (\e -> let e' = (e :: SomeException) in return ())
138− postSDist simpleUserHooks args flags desc lbi
140-- -----------------------------------------------------------------------------
223-- -----------------------------------------------------------------------------
@@ -146,10 +229,27 @@ getVersion args flags = do
146 let buildinfo = (emptyBuildInfo { cppOptions = ["-DVERSION="++hash] }) :: BuildInfo
229 let buildinfo = (emptyBuildInfo { cppOptions = ["-DVERSION="++hash] }) :: BuildInfo
147 return (Just buildinfo, [])
230 return (Just buildinfo, [])
233+#if !(MIN_VERSION_Cabal(2,0,0))
234+mkUnqualComponentName = id
237+idrisPreBuild args flags = do
238+#ifdef mingw32_HOST_OS
239+ createDirectoryIfMissingVerbose verbosity True dir
240+ windres verbosity ["icons/idris_icon.rc","-o", dir++"/idris_icon.o"]
241+ return (Nothing, [(mkUnqualComponentName "idris", emptyBuildInfo { ldOptions = [dir ++ "/idris_icon.o"] })])
243+ verbosity = S.fromFlag $ S.buildVerbosity flags
244+ dir = S.fromFlagOrDefault "dist" $ S.buildDistPref flags
246+ return (Nothing, [])
149−idrisBuild _ flags _ local = do
249+idrisBuild _ flags _ local
152− when (usesLLVM $ configFlags local) buildLLVM
250+ = if (execOnly (configFlags local)) then buildRTS
154 verbosity = S.fromFlag $ S.buildVerbosity flags
254 verbosity = S.fromFlag $ S.buildVerbosity flags
@@ -159,50 +259,63 @@ idrisBuild _ flags _ local = do
160 makeBuild dir = make verbosity [ "-C", dir, "build" , "IDRIS=" ++ idrisCmd local]
260 makeBuild dir = make verbosity [ "-C", dir, "build" , "IDRIS=" ++ idrisCmd local]
162− buildRTS = make verbosity (["-C", "rts", "build"] ++
262+ buildRTS = make verbosity (["-C", "rts", "build"] ++
163 gmpflag (usesGMP (configFlags local)))
263 gmpflag (usesGMP (configFlags local)))
165− buildLLVM = make verbosity ["-C", "llvm", "build"]
167 gmpflag False = []
265 gmpflag False = []
168 gmpflag True = ["GMP=-DIDRIS_GMP"]
266 gmpflag True = ["GMP=-DIDRIS_GMP"]
171-- -----------------------------------------------------------------------------
268-- -----------------------------------------------------------------------------
172-- Copy/Install
269-- Copy/Install
174−idrisInstall verbosity copy pkg local = do
271+idrisInstall verbosity copy pkg local
272+ = if (execOnly (configFlags local)) then installRTS
175− installStdLib
273+ else do installStdLib
176− installRTS
274+ installRTS
177− when (usesLLVM $ configFlags local) installLLVM
275+ installManPage
179 target = datadir $ L.absoluteInstallDirs pkg local copy
277 target = datadir $ L.absoluteInstallDirs pkg local copy
181 installStdLib = do
279 installStdLib = do
280+ let target' = target -- </> "libs"
182− putStrLn $ "Installing libraries in " ++ target
281+ putStrLn $ "Installing libraries in " ++ target'
183− makeInstall "libs" target
282+ makeInstall "libs" target'
185 installRTS = do
284 installRTS = do
186 let target' = target </> "rts"
285 let target' = target </> "rts"
187 putStrLn $ "Installing run time system in " ++ target'
286 putStrLn $ "Installing run time system in " ++ target'
188 makeInstall "rts" target'
287 makeInstall "rts" target'
190− installLLVM = do
289+ installManPage = do
191− let target' = target </> "llvm"
290+ let mandest = mandir (L.absoluteInstallDirs pkg local copy) ++ "/man1"
192− putStrLn $ "Installing LLVM library in " ++ target
291+ notice verbosity $ unwords ["Copying man page to", mandest]
193− makeInstall "llvm" target'
292+ installOrdinaryFiles verbosity mandest [("man", "idris.1")]
195 makeInstall src target =
294 makeInstall src target =
196 make verbosity [ "-C", src, "install" , "TARGET=" ++ target, "IDRIS=" ++ idrisCmd local]
295 make verbosity [ "-C", src, "install" , "TARGET=" ++ target, "IDRIS=" ++ idrisCmd local]
297+-- -----------------------------------------------------------------------------
300+-- There are two "dataDir" in cabal, and they don't relate to each other.
301+-- When fetching modules, idris uses the second path (in the pkg record),
302+-- which by default is the root folder of the project.
303+-- We want it to be the install directory where we put the idris libraries.
304+fixPkg pkg target = pkg { dataDir = target }
306+idrisTestHook args pkg local hooks flags = do
307+ let target = datadir $ L.absoluteInstallDirs pkg local NoCopyDest
308+ testHook simpleUserHooks args (fixPkg pkg target) local hooks flags
198-- -----------------------------------------------------------------------------
310-- -----------------------------------------------------------------------------
201-- Install libraries during both copy and install
313-- Install libraries during both copy and install
202−-- See http://hackage.haskell.org/trac/hackage/ticket/718
314+-- See https://github.com/haskell/cabal/issues/709
203main = defaultMainWithHooks $ simpleUserHooks
315main = defaultMainWithHooks $ simpleUserHooks
204 { postClean = idrisClean
316 { postClean = idrisClean
205 , postConf = idrisConfigure
317 , postConf = idrisConfigure
318+ , preBuild = idrisPreBuild
206 , postBuild = idrisBuild
319 , postBuild = idrisBuild
207 , postCopy = \_ flags pkg local ->
320 , postCopy = \_ flags pkg local ->
208 idrisInstall (S.fromFlag $ S.copyVerbosity flags)
321 idrisInstall (S.fromFlag $ S.copyVerbosity flags)
@@ -210,6 +323,5 @@ main = defaultMainWithHooks $ simpleUserHooks
210 , postInst = \_ flags pkg local ->
323 , postInst = \_ flags pkg local ->
211 idrisInstall (S.fromFlag $ S.installVerbosity flags)
324 idrisInstall (S.fromFlag $ S.installVerbosity flags)
212 NoCopyDest pkg local
325 NoCopyDest pkg local
213− , preSDist = idrisPreSDist --do { putStrLn (show args) ; putStrLn (show flags) ; return emptyHookedBuildInfo }
326+ , testHook = idrisTestHook
214− , postSDist = idrisPostSDist
@@ -0,0 +1,27 @@
4+ choco install cabal --no-progress
8+ Invoke-WebRequest "https://downloads.haskell.org/~ghc/8.8.2/ghc-8.8.2-x86_64-unknown-mingw32.tar.xz" -OutFile C:\ghc\ghc.tar.xz -UserAgent "Curl"
10+ 7z x C:\ghc\ghc.tar.xz -oC:\ghc
12+ 7z x C:\ghc\ghc.tar -oC:\ghc
14+ $env:PATH="$env:PATH;c:\ghc\ghc-8.8.2\bin;$HOME\AppData\Roaming\cabal\bin"
18+ $env:current_posix=c:\msys64\usr\bin\cygpath -u $(pwd)
22+ MSYS2_PATH_TYPE: inherit
25+ c:\msys64\usr\bin\bash -l -c "cd $env:current_posix && cabal v1-install -fffi --enable-tests 2>&1"
27+- ps: c:\msys64\usr\bin\bash -l -c "cd $env:current_posix && make test_c 2>&1"
azure-pipelines.ymlnew file+143
@@ -0,0 +1,143 @@
2+# Start with a minimal pipeline that you can customize to build and deploy your code.
3+# Add steps that build, run tests, deploy, and more:
6+ # Test a configuration with the oldest supported GHC
9+ vmImage: 'Ubuntu 16.04'
12+ sudo add-apt-repository ppa:hvr/ghc
14+ sudo apt-get install ghc-7.10.3 cabal-install-2.2
15+ sudo update-alternatives --config opt-ghc
16+ sudo update-alternatives --config opt-cabal
17+ displayName: 'Prepare system'
19+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH
21+ CABALFLAGS="-fffi -fci" make
22+ displayName: 'Build Idris'
24+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH
26+ displayName: 'Run tests'
30+ vmImage: 'Ubuntu 16.04'
33+ sudo add-apt-repository ppa:hvr/ghc
35+ sudo apt-get install ghc-8.2.2 cabal-install-2.2
36+ sudo update-alternatives --config opt-ghc
37+ sudo update-alternatives --config opt-cabal
38+ displayName: 'Prepare system'
40+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH
42+ CABALFLAGS="-fffi -fci" make
43+ displayName: 'Build Idris'
45+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH
47+ displayName: 'Run tests'
51+ vmImage: 'xcode9-macos10.13'
54+ brew install ghc cabal-install libffi pkgconfig
55+ export PKG_CONFIG_PATH=/usr/local/opt/libffi/lib/pkgconfig:$PKG_CONFIG_PATH
56+ export PATH=$HOME/.cabal/bin:$PATH
58+ CABALFLAGS="-fffi -fci" make
60+ displayName: 'Build idris and run tests'
64+ vmImage: 'vs2017-win2016'
67+ choco install cabal -y --no-progress
68+ choco install 7zip.portable -y --no-progress
69+ choco install msys2 -y --no-progress --params "/InstallDir=C:/msys64/"
71+ Invoke-WebRequest "https://downloads.haskell.org/~ghc/8.4.3/ghc-8.4.3-x86_64-unknown-mingw32.tar.xz" -OutFile C:\ghc\ghc.tar.xz -UserAgent "Curl"
72+ 7z x C:\ghc\ghc.tar.xz -oC:\ghc
73+ 7z x C:\ghc\ghc.tar -oC:\ghc
74+ displayName: "Setting up environment"
77+ $env:PATH="$env:PATH;$HOME\AppData\Roaming\cabal\bin;c:\ghc\ghc-8.4.3\bin"
78+ $env:current_posix=c:\msys64\usr\bin\cygpath -u $(pwd)
79+ c:\msys64\usr\bin\bash -l -c "echo `$MSYSTEM && echo `$PATH"
80+ c:\msys64\usr\bin\bash -l -c "pacman -S make mingw-w64-x86_64-gcc mingw-w64-x86_64-pkg-config mingw-w64-x86_64-libffi --noconfirm 2>&1"
81+ c:\msys64\usr\bin\bash -l -c "cd $env:current_posix && cabal install -fffi --enable-test 2>&1"
82+ c:\msys64\usr\bin\bash -l -c "cd $env:current_posix && make test_c 2>&1"
85+ MSYS2_PATH_TYPE: inherit
86+ displayName: "Build and test Idris"
90+ vmImage: 'Ubuntu 16.04'
93+ sudo add-apt-repository ppa:hvr/ghc
95+ sudo apt-get install ghc-8.2.2 cabal-install-2.2
96+ sudo update-alternatives --config opt-ghc
97+ sudo update-alternatives --config opt-cabal
98+ displayName: 'Prepare system'
100+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH
102+ cabal install stylish-haskell
104+ displayName: 'Run stylish'
105+ # Run tests on the node backend
108+ vmImage: 'Ubuntu 16.04'
111+ sudo add-apt-repository ppa:hvr/ghc
113+ sudo apt-get install ghc-8.2.2 cabal-install-2.2
114+ sudo update-alternatives --config opt-ghc
115+ sudo update-alternatives --config opt-cabal
116+ displayName: 'Prepare system'
118+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH
120+ CABALFLAGS="-fffi -fci" make
121+ displayName: 'Build Idris'
123+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH
125+ displayName: 'Run tests'
129+ vmImage: 'Ubuntu 16.04'
132+ sudo add-apt-repository ppa:hvr/ghc
134+ sudo apt-get install ghc-8.2.2 cabal-install-2.2
135+ sudo update-alternatives --config opt-ghc
136+ sudo update-alternatives --config opt-cabal
137+ displayName: 'Prepare system'
139+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH
141+ CABALFLAGS="-fffi -fci" make
143+ displayName: 'Build Docs'
@@ -1,2 +1,4 @@
1trivial/sortvec 2000
1trivial/sortvec 2000
2quasigroups/qgsolve board
2quasigroups/qgsolve board
@@ -2,13 +2,14 @@
3$bmarks = `cat ALL`;
3$bmarks = `cat ALL`;
4@bm = split(/\n/, $bmarks);
4@bm = split(/\n/, $bmarks);
5+$idris = $ENV{'IDRIS'} || "idris";
6foreach $b (@bm) {
7foreach $b (@bm) {
7 if ($b =~ /([a-zA-Z0-9]+)\/([a-zA-Z0-9]+)\s+(.*)/) {
8 if ($b =~ /([a-zA-Z0-9]+)\/([a-zA-Z0-9]+)\s+(.*)/) {
8 print "Building $1 / $2\n";
9 print "Building $1 / $2\n";
10− system("idris --clean $2.ipkg");
11+ system("$idris --clean $2.ipkg");
11− system("idris --build $2.ipkg");
12+ system("$idris --build $2.ipkg") == 0 or die "Unable to build $2: $?";
12 chdir "..";
13 chdir "..";
benchmarks/fasta/fasta.idrnew file+88
@@ -0,0 +1,88 @@
6+alu = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG"
7+ ++ "TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG"
8+ ++ "CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC"
9+ ++ "GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
11+{- The following string literal syntax doesn't work anymore. Until fixed we shall concat the strings.
12+alu = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\
13+ \TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\
14+ \CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC\
15+ \GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
20+iub : List (Char, Double)
21+iub = [('a',0.27),('c',0.12),('g',0.12),('t',0.27),('B',0.02)
22+ ,('D',0.02),('H',0.02),('K',0.02),('M',0.02),('N',0.02)
23+ ,('R',0.02),('S',0.02),('V',0.02),('W',0.02),('Y',0.02)]
25+homosapiens : List (Char, Double)
26+homosapiens = [('a',0.3029549426680),('c',0.1979883004921)
27+ ,('g',0.1975473066391),('t',0.3015094502008)]
30+takeRepeat : Int -> String -> String
31+takeRepeat n s = if n > m
32+ then s ++ takeRepeat (n-m) s
33+ else pack $ take (cast n) $ unpack s
37+splitAt' : Nat -> String -> (String, String)
38+splitAt' n s = let s' = unpack s in (pack $ take n s', pack $ drop n s')
40+writeAlu : String -> String -> IO ()
41+writeAlu name s0 = putStrLn name *> go s0
44+ go s = let (h,t) = splitAt' 60 s in putStrLn h *> go t
46+replicate : Int -> Char -> String
48+replicate n c = singleton c <+> replicate (n-1) c
51+accum : (Char,Double) -> (Char,Double) -> (Char,Double)
52+accum (_,p) (c,q) = (c,p+q)
54+make : String -> Int -> List (Char, Double) -> Int -> IO Int
55+make name n0 tbl seed0 = do
62+ fill : List (Char,Double) -> Int -> List String
63+ fill ((c,p) :: cps) j =
64+ let k = min modulus (cast (cast modulus * p + 1))
65+ in replicate (k - j) c :: fill cps k
69+ lookupTable = Foldable.concat (fill (scanl accum ('a',0) tbl) 0)
71+ make' : Int -> Int -> Int -> String -> IO Int
72+ make' 0 col seed buf = when (col > 0) (putStrLn buf) *> pure seed
73+ make' n col seed buf = do
74+ let newseed = modInt (seed * 3877 + 29573) modulus
75+ let nextchar = strIndex lookupTable newseed
76+ let newbuf = buf <+> singleton nextchar
78+ then putStrLn newbuf *> make' (n-1) 0 newseed ""
79+ else make' (n-1) (col+1) newseed newbuf
84+ (_ :: n :: _) <- getArgs
85+ writeAlu ">ONE Homo sapiens alu" (takeRepeat (fromInteger (cast n)*2) alu)
86+ nseed <- make ">TWO IUB ambiguity codes" (fromInteger (cast n)*3) iub 42
87+ make ">THREE Homo sapiens frequency" (fromInteger (cast n)*5) homosapiens nseed
benchmarks/fasta/fasta.ipkgnew file+6
benchmarks/pidigits/pidigits.idrnew file+52
@@ -0,0 +1,52 @@
4+{- Toy program that outputs the n first digits of Pi.
6+ Inspired from https://www.haskell.org/haskellwiki/Shootout/Pidigits.
7+ The original ns and str lazy lists have been replaced by strict functions.
9+ Memory usage seems to be excessive. One of the branches of str is tail recursive, and
10+ the other one only needs to cons an extra Integer.
12+ For reference, the Haskell version runs in 0m0.230s when printing to /dev/null.
13+ It almost runs in constant space.
16+data F = MkF Integer Integer Integer
18+-- Prints the list of digits by groups of 10
19+loop : Nat -> Nat -> List Integer -> IO()
20+loop n k' Nil = putStrLn $ (pack $ Vect.replicate n ' ') ++ "\t:" ++ show k'
21+loop Z k' xs = do putStrLn ("\t:"++show k')
23+loop (S k) k' (x::xs) = do putStr (show x)
27+fn k = MkF k (4*k+2) (2*k+1)
29+flr : Integer -> F -> Integer
30+flr x (MkF q r t) = (q*x + r) `div` t
33+comp (MkF q r t) (MkF u v x) = MkF (q*u) (q*v+r*x) (t*x)
35+-- Returns the list of digits of pi. Memory hungry.
36+str : F -> Integer -> Nat -> List Integer
38+str z k (S n) = if(y == flr 4 z)
39+ then y :: str (comp (MkF 10 (-10*y) 1) z ) k n
40+ else str (comp z (fn k)) (k+1) (S n)
46+ let n = fromIntegerNat (the Integer (cast a))
47+ let l = str (MkF 1 0 1) 1 n
benchmarks/pidigits/pidigits.ipkgnew file+6
benchmarks/quasigroups/Main.idr+14−11
@@ -10,15 +10,18 @@ main = do
10 case args of
10 case args of
11 [_, path] => do
11 [_, path] => do
12 f <- readFile path
12 f <- readFile path
14+ Left _err => putStrLn $ "Error reading file: " ++ path
13− case parse f of
16+ case parse f' of
14− Left err => putStrLn err
17+ Left err => putStrLn err
15− Right (_ ** (board ** legal)) => do
18+ Right (_ ** (board ** legal)) => do
16− putStrLn "Got board:"
19+ putStrLn "Got board:"
17− print board
20+ printLn board
18− putStrLn "Solving..."
21+ putStrLn "Solving..."
19− case fillBoard board legal of
22+ case fillBoard board legal of
20− Nothing => putStrLn "No solution found"
23+ Nothing => putStrLn "No solution found"
21− Just (solved ** _) => do
24+ Just (solved ** _) => do
22− putStrLn "Solution found:"
25+ putStrLn "Solution found:"
23− print solved
26+ printLn solved
24 [self] => putStrLn ("Usage: " ++ self ++ " <board file>")
27 [self] => putStrLn ("Usage: " ++ self ++ " <board file>")
benchmarks/quasigroups/Parser.idr+18−15
@@ -1,9 +1,12 @@
1module Parser
1module Parser
3import Decidable.Equality
3import Decidable.Equality
5import Solver
6import Solver
7ParseErr : Type
10ParseErr : Type
8ParseErr = String
11ParseErr = String
@@ -11,24 +14,24 @@ Parser : Nat -> Type
11Parser n = Either ParseErr (b : Board n ** LegalBoard b)
14Parser n = Either ParseErr (b : Board n ** LegalBoard b)
13mapM : Monad m => (a -> m b) -> Vect n a -> m (Vect n b)
16mapM : Monad m => (a -> m b) -> Vect n a -> m (Vect n b)
14−mapM _ Nil = return Vect.Nil
17+mapM _ Nil = pure Vect.Nil
15mapM f (x::xs) = do
18mapM f (x::xs) = do
17 xs' <- mapM f xs
20 xs' <- mapM f xs
18− return (Vect.(::) x' xs')
21+ pure (Vect.(::) x' xs')
20parseToken : String -> Either String (Cell n)
23parseToken : String -> Either String (Cell n)
21−parseToken "." = return Nothing
24+parseToken "." = pure Nothing
22parseToken "0" = Left "Got cell 0, expected 1-based numbering"
25parseToken "0" = Left "Got cell 0, expected 1-based numbering"
23parseToken x = map Just (tryParseFin ((cast x) - 1))
26parseToken x = map Just (tryParseFin ((cast x) - 1))
25 tryParseFin : Int -> Either String (Fin n)
28 tryParseFin : Int -> Either String (Fin n)
26 tryParseFin {n=Z} _ = Left ("Given cell " ++ x ++ " out of range")
29 tryParseFin {n=Z} _ = Left ("Given cell " ++ x ++ " out of range")
27− tryParseFin {n=S k} 0 = return fZ
30+ tryParseFin {n=S k} 0 = pure FZ
28 tryParseFin {n=S k} x =
31 tryParseFin {n=S k} x =
29 case tryParseFin {n=k} (x-1) of
32 case tryParseFin {n=k} (x-1) of
30 Left err => Left err
33 Left err => Left err
31− Right fin => return (fS fin)
34+ Right fin => pure (FS fin)
33length : Vect n a -> Nat
36length : Vect n a -> Nat
34length {n=n} _ = n
37length {n=n} _ = n
@@ -42,16 +45,16 @@ parseCols {n=S k} row l cs = helper last l
42 let here = (x, row) -- TODO: Determine why naming this makes idris smarter
45 let here = (x, row) -- TODO: Determine why naming this makes idris smarter
43 tok <- parseToken {n=S k} (index x cs)
46 tok <- parseToken {n=S k} (index x cs)
44 case tok of
47 case tok of
45− Nothing => return (_ ** l)
48+ Nothing => pure (_ ** l)
47 case legalVal b here t of
50 case legalVal b here t of
48 Yes prf => Right (_ ** Step prf l)
51 Yes prf => Right (_ ** Step prf l)
49 No _ => Left ("Illegal cell " ++ index x cs)
52 No _ => Left ("Illegal cell " ++ index x cs)
51 helper : {b : Board (S k)} -> Fin (S k) -> LegalBoard b -> Parser (S k)
54 helper : {b : Board (S k)} -> Fin (S k) -> LegalBoard b -> Parser (S k)
52− helper fZ l = step l fZ
55+ helper FZ l = step l FZ
53− helper (fS k) l = do
56+ helper (FS k) l = do
54− (_ ** next) <- step l (fS k)
57+ (_ ** next) <- step l (FS k)
55 helper (weaken k) next
58 helper (weaken k) next
57parseRows : (b : Board n) -> LegalBoard b -> Vect n String -> Parser n
60parseRows : (b : Board n) -> LegalBoard b -> Vect n String -> Parser n
@@ -61,14 +64,14 @@ parseRows {n=S k} _ l rs = helper last l
61 step : {b : Board (S k)} -> Fin (S k) -> LegalBoard b -> Parser (S k)
64 step : {b : Board (S k)} -> Fin (S k) -> LegalBoard b -> Parser (S k)
62 step i l =
65 step i l =
63 let cs = fromList (words (index i rs)) in
66 let cs = fromList (words (index i rs)) in
64− case decEq (length cs) (S k) of
67+ case decEq (Parser.length cs) (S k) of
65 No _ => Left "Row length not equal to column height"
68 No _ => Left "Row length not equal to column height"
66− Yes prf => let foo = (replace {P=\n => Vect n String} prf cs) in parseCols i l foo -- TODO: foo shouldn't be needed
69+ Yes prf => parseCols i l (replace {P=\n => Vect n String} prf cs)
68 helper : {b : Board (S k)} -> Fin (S k) -> LegalBoard b -> Parser (S k)
71 helper : {b : Board (S k)} -> Fin (S k) -> LegalBoard b -> Parser (S k)
69− helper fZ l = step fZ l
72+ helper FZ l = step FZ l
70− helper (fS k) l = do
73+ helper (FS k) l = do
71− (_ ** next) <- step (fS k) l
74+ (_ ** next) <- step (FS k) l
72 helper (weaken k) next
75 helper (weaken k) next
74parse : String -> Either String (n : Nat ** (b : Board n ** LegalBoard b))
77parse : String -> Either String (n : Nat ** (b : Board n ** LegalBoard b))
@@ -76,4 +79,4 @@ parse str =
76 let rows = fromList (lines str) in
79 let rows = fromList (lines str) in
77 case parseRows {n=length rows} emptyBoard Base rows of
80 case parseRows {n=length rows} emptyBoard Base rows of
78 Left msg => Left msg
81 Left msg => Left msg
79− Right board => return (_ ** board)
82+ Right board => pure (_ ** board)
benchmarks/quasigroups/Solver.idr+22−22
@@ -2,9 +2,11 @@ module Solver
3import Decidable.Equality
3import Decidable.Equality
4import Control.Monad.State
4import Control.Monad.State
5import Data.Vect.Quantifiers
6import Data.Vect.Quantifiers
7%default total
8%default total
9Cell : Nat -> Type
11Cell : Nat -> Type
10Cell n = Maybe (Fin n)
12Cell n = Maybe (Fin n)
@@ -31,12 +33,12 @@ unlines (l::ls) = pack (foldl addLine (unpack l) (map unpack ls))
31 addLine : List Char -> List Char -> List Char
33 addLine : List Char -> List Char -> List Char
32 addLine w s = w ++ ('\n' :: s)
34 addLine w s = w ++ ('\n' :: s)
34−instance Show (Board n) where
36+Show (Board n) where
35 show (MkBoard rs) = unlines (map showRow rs)
37 show (MkBoard rs) = unlines (map showRow rs)
37updateAt : Fin n -> Vect n a -> (a -> a) -> Vect n a
39updateAt : Fin n -> Vect n a -> (a -> a) -> Vect n a
38−updateAt fZ (x::xs) f = f x :: xs
40+updateAt FZ (x::xs) f = f x :: xs
39−updateAt (fS i) (x::xs) f = x :: updateAt i xs f
41+updateAt (FS i) (x::xs) f = x :: updateAt i xs f
41setCell : Board n -> (Fin n, Fin n) -> Fin n -> Board n
43setCell : Board n -> (Fin n, Fin n) -> Fin n -> Board n
42setCell (MkBoard b) (x, y) value = MkBoard (updateAt y b (\row => updateAt x row (const (Just value))))
44setCell (MkBoard b) (x, y) value = MkBoard (updateAt y b (\row => updateAt x row (const (Just value))))
@@ -80,7 +82,7 @@ Empty : Cell n -> Type
80Empty {n=n} x = (the (Cell n) Nothing) = x
82Empty {n=n} x = (the (Cell n) Nothing) = x
82empty : (cell : Cell n) -> Dec (Empty cell)
84empty : (cell : Cell n) -> Dec (Empty cell)
83−empty Nothing = Yes refl
85+empty Nothing = Yes Refl
84empty (Just _) = No nothingNotJust
86empty (Just _) = No nothingNotJust
86-- Predicate for legal cell assignments
88-- Predicate for legal cell assignments
@@ -95,7 +97,7 @@ legalVal b (x, y) v =
95 case colSafe b x v of
97 case colSafe b x v of
96 No prf' => No (\(_, cf, _) => prf' cf)
98 No prf' => No (\(_, cf, _) => prf' cf)
97 Yes prf' =>
99 Yes prf' =>
98− case empty (getCell b (x, y)) of
100+ case Solver.empty (getCell b (x, y)) of
99 No prf'' => No (\(ef, _, _) => prf'' ef)
101 No prf'' => No (\(ef, _, _) => prf'' ef)
100 Yes prf'' => Yes (prf'', prf', prf)
102 Yes prf'' => Yes (prf'', prf', prf)
@@ -103,11 +105,11 @@ legalVal b (x, y) v =
103Filled : Cell n -> Type
105Filled : Cell n -> Type
104--Filled {n=n} x = Not (Empty x) -- TODO: Find out why this doesn't work
106--Filled {n=n} x = Not (Empty x) -- TODO: Find out why this doesn't work
105Filled {n=n} = (\x => Not (Empty x))
107Filled {n=n} = (\x => Not (Empty x))
106−--Filled {n=n} x = the (Maybe (Fin n)) Nothing = x -> _|_
108+--Filled {n=n} x = the (Maybe (Fin n)) Nothing = x -> Void
107−--Filled {n=n} = \x => the (Maybe (Fin n)) Nothing = x -> _|_
109+--Filled {n=n} = \x => the (Maybe (Fin n)) Nothing = x -> Void
109filled : (cell : Cell n) -> Dec (Filled cell)
111filled : (cell : Cell n) -> Dec (Filled cell)
110−filled Nothing = No (\f => f refl)
112+filled Nothing = No (\f => f Refl)
111filled (Just _) = Yes nothingNotJust
113filled (Just _) = Yes nothingNotJust
113FullBoard : Board n -> Type
115FullBoard : Board n -> Type
@@ -127,18 +129,18 @@ data LegalBoard : Board n -> Type where
127CompleteBoard : Board n -> Type
129CompleteBoard : Board n -> Type
128CompleteBoard b = (LegalBoard b, FullBoard b)
130CompleteBoard b = (LegalBoard b, FullBoard b)
130−indexStep : {i : Fin n} -> {xs : Vect n a} -> {x : a} -> index i xs = index (fS i) (x::xs)
132+indexStep : {i : Fin n} -> {xs : Vect n a} -> {x : a} -> index i xs = index (FS i) (x::xs)
131−indexStep = refl
133+indexStep = Refl
133find : {P : a -> Type} -> ((x : a) -> Dec (P x)) -> (xs : Vect n a)
135find : {P : a -> Type} -> ((x : a) -> Dec (P x)) -> (xs : Vect n a)
134 -> Either (All (\x => Not (P x)) xs) (y : a ** (P y, (i : Fin n ** y = index i xs)))
136 -> Either (All (\x => Not (P x)) xs) (y : a ** (P y, (i : Fin n ** y = index i xs)))
135find _ Nil = Left Nil
137find _ Nil = Left Nil
136find d (x::xs) with (d x)
138find d (x::xs) with (d x)
137− | Yes prf = Right (x ** (prf, (fZ ** refl)))
139+ | Yes prf = Right (x ** (prf, (FZ ** Refl)))
138 | No prf =
140 | No prf =
139 case find d xs of
141 case find d xs of
140 Right (y ** (prf', (i ** prf''))) =>
142 Right (y ** (prf', (i ** prf''))) =>
141− Right (y ** (prf', (fS i ** replace {P=(\x => y = x)} (indexStep {x=x}) prf'')))
143+ Right (y ** (prf', (FS i ** replace {P=(\x => y = x)} (indexStep {x=x}) prf'')))
142 Left prf' => Left (prf::prf')
144 Left prf' => Left (prf::prf')
144findEmptyInRow : (xs : Vect n (Cell n)) -> Either (All Filled xs) (i : Fin n ** Empty (index i xs))
146findEmptyInRow : (xs : Vect n (Cell n)) -> Either (All Filled xs) (i : Fin n ** Empty (index i xs))
@@ -158,11 +160,11 @@ emptyCell (MkBoard rs) =
158 helper Nil = Left Nil
160 helper Nil = Left Nil
159 helper (r::rs) =
161 helper (r::rs) =
160 case findEmptyInRow r of
162 case findEmptyInRow r of
161− Right (ci ** pf) => Right (fZ ** (ci ** pf))
163+ Right (ci ** pf) => Right (FZ ** (ci ** pf))
162 Left prf =>
164 Left prf =>
163 case helper rs of
165 case helper rs of
164 Left prf' => Left (prf::prf')
166 Left prf' => Left (prf::prf')
165− Right (ri ** (ci ** pf)) => Right (fS ri ** (ci ** pf))
167+ Right (ri ** (ci ** pf)) => Right (FS ri ** (ci ** pf))
168tryValue : {b : Board (S n)} -> LegalBoard b -> (c : (Fin (S n), Fin (S n))) -> Empty (getCell b c) -> (v : Fin (S n))
170tryValue : {b : Board (S n)} -> LegalBoard b -> (c : (Fin (S n), Fin (S n))) -> Empty (getCell b c) -> (v : Fin (S n))
@@ -182,23 +184,21 @@ fillBoard {n=(S n)} b l with (emptyCell b)
182 | Left full = Just (b ** (l, full))
184 | Left full = Just (b ** (l, full))
183 | Right (coords ** p) = recurse last
185 | Right (coords ** p) = recurse last
186 tryAll : (v : Fin (S n)) -> (Fin (S n), Maybe (b' : Board (S n) ** LegalBoard b'))
187 tryAll : (v : Fin (S n)) -> (Fin (S n), Maybe (b' : Board (S n) ** LegalBoard b'))
187− tryAll v = --trace ("Trying " ++ show (the Int (cast v))) $
188+ tryAll v = assert_total $ --trace ("Trying " ++ show (the Int (cast v))) $
188 case tryValue l coords p v of
189 case tryValue l coords p v of
189 Right success => (v, Just success)
190 Right success => (v, Just success)
190 Left _ => -- TODO: Prove unsolvable
191 Left _ => -- TODO: Prove unsolvable
191 case v of
192 case v of
192− fS k => tryAll (weaken k)
193+ FS k => tryAll (weaken k)
193− fZ => (v, Nothing)
194+ FZ => (v, Nothing)
196 recurse : Fin (S n) -> Maybe (b' : Board (S n) ** CompleteBoard b')
196 recurse : Fin (S n) -> Maybe (b' : Board (S n) ** CompleteBoard b')
197− recurse start =
197+ recurse start = assert_total $
198 case tryAll start of
198 case tryAll start of
199 (_, Nothing) => Nothing
199 (_, Nothing) => Nothing
200− (fZ, Just (b' ** l')) => fillBoard b' l'
200+ (FZ, Just (b' ** l')) => fillBoard b' l'
201− (fS next, Just (b' ** l')) =>
201+ (FS next, Just (b' ** l')) =>
202 case fillBoard b' l' of
202 case fillBoard b' l' of
203 Just solution => Just solution
203 Just solution => Just solution
204 Nothing => recurse (weaken next)
204 Nothing => recurse (weaken next)
benchmarks/trivial/sortvec.idr+7−7
@@ -1,7 +1,9 @@
3import System
3import System
4import Effect.Random
5import Effect.Random
7insert : Ord a => a -> Vect n a -> Vect (S n) a
9insert : Ord a => a -> Vect n a -> Vect (S n) a
@@ -12,14 +14,12 @@ vsort : Ord a => Vect n a -> Vect n a
12vsort [] = []
14vsort [] = []
13vsort (x :: xs) = insert x (vsort xs)
15vsort (x :: xs) = insert x (vsort xs)
15−mkSortVec : (n : Nat) -> Eff m [RND] (Vect n Int)
17+mkSortVec : (n : Nat) -> Eff (Vect n Int) [RND]
16−mkSortVec Z = return []
18+mkSortVec Z = pure []
17−mkSortVec (S k) = return (fromInteger !(rndInt 0 10000) :: !(mkSortVec k))
19+mkSortVec (S k) = pure (fromInteger !(rndInt 0 10000) :: !(mkSortVec k))
19main : IO ()
21main : IO ()
20main = do (_ :: arg :: _) <- getArgs
22main = do (_ :: arg :: _) <- getArgs
22− let vec = runPure [123456789] (mkSortVec (fromInteger (cast arg)))
23+ let vec = runPure $ (srand 123456789 *> mkSortVec (fromInteger (cast arg)))
23 putStrLn "Made vector"
24 putStrLn "Made vector"
24− print (vsort vec)
25+ printLn (vsort vec)
codegen/idris-codegen-c/Main.hsnew file+49
@@ -0,0 +1,49 @@
13+import System.Environment
18+data Opts = Opts { inputs :: [FilePath],
22+showUsage = do putStrLn "A code generator which is intended to be called by the compiler, not by a user."
23+ putStrLn "Usage: idris-codegen-c <ibc-files> [-o <output-file>]"
27+getOpts = do xs <- getArgs
28+ return $ process (Opts [] False "a.out") xs
30+ process opts ("-o":o:xs) = process (opts { output = o }) xs
31+ process opts ("--interface":xs) = process (opts { interface = True }) xs
32+ process opts (x:xs) = process (opts { inputs = x:inputs opts }) xs
33+ process opts [] = opts
35+c_main :: Opts -> Idris ()
36+c_main opts = do runIO setupBundledCC
38+ loadInputs (inputs opts) Nothing
39+ mainProg <- if interface opts
40+ then liftM Just elabMain
42+ ir <- compile (Via IBCFormat "c") (output opts) mainProg
46+main = do opts <- getOpts
47+ if (null (inputs opts))
49+ else runMain (c_main opts)
codegen/idris-codegen-javascript/Main.hsnew file+42
@@ -0,0 +1,42 @@
7+import IRTS.CodegenJavaScript
10+import System.Environment
19+showUsage = do putStrLn "A code generator which is intended to be called by the compiler, not by a user."
20+ putStrLn "Usage: idris-codegen-javascript <ibc-files> [-o <output-file>]"
24+getOpts = do xs <- getArgs
25+ return $ process (Opts [] "main.js") xs
27+ process opts ("-o":o:xs) = process (opts { output = o }) xs
28+ process opts (x:xs) = process (opts { inputs = x:inputs opts }) xs
29+ process opts [] = opts
31+jsMain :: Opts -> Idris ()
32+jsMain opts = do elabPrims
33+ loadInputs (inputs opts) Nothing
35+ ir <- compile (Via IBCFormat "javascript") (output opts) (Just mainProg)
36+ runIO $ codegenJavaScript ir
39+main = do opts <- getOpts
40+ if (null (inputs opts))
42+ else runMain (jsMain opts)
codegen/idris-codegen-node/Main.hsnew file+48
@@ -0,0 +1,48 @@
7+import IRTS.CodegenJavaScript
14+import System.Environment
17+data Opts = Opts { inputs :: [FilePath]
22+showUsage = do putStrLn "A code generator which is intended to be called by the compiler, not by a user."
23+ putStrLn "Usage: idris-codegen-node <ibc-files> [-o <output-file>]"
27+getOpts = do xs <- getArgs
28+ return $ process (Opts [] False "main.js") xs
30+ process opts ("-o":o:xs) = process (opts { output = o }) xs
31+ process opts ("--interface":xs) = process (opts { interface = True }) xs
32+ process opts (x:xs) = process (opts { inputs = x:inputs opts }) xs
33+ process opts [] = opts
35+jsMain :: Opts -> Idris ()
36+jsMain opts = do elabPrims
37+ loadInputs (inputs opts) Nothing
38+ mainProg <- if interface opts
40+ else liftM Just elabMain
41+ ir <- compile (Via IBCFormat "node") (output opts) mainProg
42+ runIO $ codegenNode ir
45+main = do opts <- getOpts
46+ if (null (inputs opts))
48+ else runMain (jsMain opts)
@@ -1,9 +1,26 @@
1−CC :=cc
1+UNAME_INFO := $(shell uname -a)
3+ifeq ($(filter , $(findstring MSYS, $(UNAME_INFO)) $(findstring MINGW, $(UNAME_INFO))),)
5+ # In MSYS2, when using the mingw version of gcc, there is no cc -> gcc
6+ # symlink. We can't use ?= here because CC is set implicitly to cc.
7+ # Cross compiling users can set CC to their cross compiler.
2CABAL :=cabal
14CABAL :=cabal
3−CFLAGS :=-O2 -Wall $(CFLAGS)
15+# IDRIS_ENABLE_STATS should not be set in final release
16+# Any flags defined here which alter the RTS API must also be added to src/IRTS/CodegenC.hs
17+CFLAGS :=-O2 -Wall -std=c99 -pipe -fdata-sections -ffunction-sections -D_POSIX_C_SOURCE=200809L -DHAS_PTHREAD -DIDRIS_ENABLE_STATS $(CFLAGS)
4−#CABALFLAGS :=
19+# CABALFLAGS :=
20+CABALFLAGS += --enable-tests
5## Disable building of Effects
21## Disable building of Effects
6−#CABALFLAGS :=-f NoEffects
22+#CABALFLAGS :=-f NoEffects $(CABALFLAGS)
8ifneq (, $(findstring bsd, $(MACHINE)))
25ifneq (, $(findstring bsd, $(MACHINE)))
9 GMP_INCLUDE_DIR :=
26 GMP_INCLUDE_DIR :=
@@ -14,25 +31,20 @@ endif
14MACHINE := $(shell $(CC) -dumpmachine)
31MACHINE := $(shell $(CC) -dumpmachine)
15ifneq (, $(findstring darwin, $(MACHINE)))
32ifneq (, $(findstring darwin, $(MACHINE)))
16 OS :=darwin
33 OS :=darwin
18−ifneq (, $(findstring cygwin, $(MACHINE)))
34+else ifneq (, $(findstring cygwin, $(MACHINE)))
19 OS :=windows
35 OS :=windows
21−ifneq (, $(findstring mingw, $(MACHINE)))
36+else ifneq (, $(findstring mingw, $(MACHINE)))
38+else ifneq (, $(findstring windows, $(MACHINE)))
22 OS :=windows
39 OS :=windows
29ifeq ($(OS),darwin)
44ifeq ($(OS),darwin)
30 SHLIB_SUFFIX :=.dylib
45 SHLIB_SUFFIX :=.dylib
32−ifeq ($(OS),windows)
46+else ifeq ($(OS),windows)
33 SHLIB_SUFFIX :=.DLL
47 SHLIB_SUFFIX :=.DLL
35 SHLIB_SUFFIX :=.so
49 SHLIB_SUFFIX :=.so
contribs/gtksourceview-2.0-language-spec/idris.langdeleted−254
@@ -1,254 +0,0 @@
1−<?xml version="1.0" encoding="UTF-8"?>
4− Author: Dominic Mulligan
5− Copyright (C) 2012 Dominic Mulligan <dominic.p.mulligan@gmail.com>
7− Lexemes taken from src/Idris/Parser.hs.
9− Based on the gtksourceview-2.0 Haskell style by:
11− Authors: Duncan Coutts, Anders Carlsson
12− Copyright (C) 2004, 2007 Duncan Coutts <duncan@haskell.org>
13− Copyright (C) 2004 Anders Carlsson <andersca@gnome.org>
15− This library is free software; you can redistribute it and/or
16− modify it under the terms of the GNU Library General Public
17− License as published by the Free Software Foundation; either
18− version 2 of the License, or (at your option) any later version.
20− This library is distributed in the hope that it will be useful,
21− but WITHOUT ANY WARRANTY; without even the implied warranty of
22− MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23− Library General Public License for more details.
25− You should have received a copy of the GNU Library General Public
26− License along with this library; if not, write to the
27− Free Software Foundation, Inc., 59 Temple Place - Suite 330,
28− Boston, MA 02111-1307, USA.
31−<language id="idris" _name="Idris" version="2.0" _section="Sources">
33− <property name="mimetypes">text/x-idris</property>
34− <property name="globs">*.idr</property>
38− <style id="preprocessor" _name="Preprocessor" map-to="def:preprocessor"/>
39− <style id="comment" _name="Comment" map-to="def:comment"/>
40− <style id="variable" _name="Variable" />
41− <style id="symbol" _name="Symbol" />
42− <style id="keyword" _name="Keyword" map-to="def:keyword"/>
43− <style id="tactic" _name="Tactic" map-to="def:keyword"/>
44− <style id="type" _name="Data Type" map-to="def:type"/>
45− <style id="string" _name="String" map-to="def:string"/>
46− <style id="character" _name="Character" map-to="def:character"/>
47− <style id="char-escape" _name="Escaped Character" map-to="def:special-char"/>
48− <style id="decimal" _name="Decimal" map-to="def:decimal"/>
49− <style id="float" _name="Float" map-to="def:floating-point"/>
53− <define-regex id="symbolchar">[!#$%&*+./>=<?@:\\^|~-]</define-regex>
55− <context id="line-comment" style-ref="comment" end-at-line-end="true" class="comment" class-disabled="no-spell-check">
56− <start>(?<!\%{symbolchar})--+(?!\%{symbolchar})</start>
58− <context ref="def:in-comment"/>
59− <context ref="haddock:line-paragraph"/>
60− <context ref="haddock:directive"/>
64− <context id="block-comment" style-ref="comment" class="comment" class-disabled="no-spell-check">
68− <context ref="def:in-comment"/>
69− <context ref="haddock:block-paragraph"/>
70− <context ref="haddock:directive"/>
71− <context ref="block-comment"/>
75− <context id="variable" style-ref="variable">
76− <match>\b[a-z_][0-9a-zA-Z_'#]*</match>
79− <context id="type-or-constructor" style-ref="type">
80− <match>\b[A-Z][0-9a-zA-Z._'#]*</match>
83− <context id="symbol" style-ref="symbol" extend-parent="false">
84− <match>\%{symbolchar}+</match>
87− <context id="keysymbol" style-ref="keyword">
88− <prefix>(?<!\%{symbolchar})</prefix>
89− <suffix>(?!\%{symbolchar})</suffix>
90− <keyword>\.</keyword>
94− <keyword>\|</keyword>
96− <keyword>-></keyword>
99− <keyword>=></keyword>
100− <keyword>\(\)</keyword>
101− <keyword>\_\|\_</keyword>
102− <keyword>\*\*</keyword>
105− <define-regex id="escaped-character" extended="true">
106− \\( # leading backslash
107− [abfnrtv\\"\'&] | # escaped character
108− [0-9]+ | # decimal digits
109− o[0-7]+ | # 'o' followed by octal digits
110− x[0-9A-Fa-f]+ | # 'x' followed by hex digits
111− \^[A-Z@\[\\\]^_] | # control character codes
112− NUL | SOH | STX | ETX | EOT | ENQ | ACK |
113− BEL | BS | HT | LF | VT | FF | CR | SO |
114− SI | DLE | DC1 | DC2 | DC3 | DC4 | NAK |
115− SYN | ETB | CAN | EM | SUB | ESC | FS | GS |
116− RS | US | SP | DEL # control char names
120− <context id="string" style-ref="string" end-at-line-end="true" class="string" class-disabled="no-spell-check">
124− <context ref="def:line-continue"/>
125− <context style-ref="char-escape">
126− <match>\%{escaped-character}</match>
131− <context id="char" style-ref="character" end-at-line-end="true">
135− <context style-ref="char-escape" once-only="true">
136− <match>\%{escaped-character}</match>
138− <context once-only="true" extend-parent="false">
141− <context style-ref="def:error" extend-parent="false">
147− <context id="float" style-ref="float">
148− <match extended="true">
149− [0-9]+ \. [0-9]+ ([eE][+-]?[0-9]+)?
150− | [0-9]+ [eE][+-]?[0-9]+
154− <context id="decimal" style-ref="decimal">
155− <match>[0-9]+</match>
158− <context id="keyword" style-ref="keyword">
159− <keyword>Set</keyword>
160− <keyword>case</keyword>
161− <keyword>class</keyword>
162− <keyword>data</keyword>
163− <keyword>default</keyword>
164− <keyword>do</keyword>
165− <keyword>record</keyword>
166− <keyword>foreign</keyword>
167− <keyword>lib</keyword>
168− <keyword>link</keyword>
169− <keyword>include</keyword>
170− <keyword>hide</keyword>
171− <keyword>freeze</keyword>
172− <keyword>access</keyword>
173− <keyword>logging</keyword>
174− <keyword>abstract</keyword>
175− <keyword>public</keyword>
176− <keyword>private</keyword>
177− <keyword>namespace</keyword>
178− <keyword>syntax</keyword>
179− <keyword>term</keyword>
180− <keyword>pattern</keyword>
181− <keyword>params</keyword>
182− <keyword>import</keyword>
183− <keyword>using</keyword>
184− <keyword>in</keyword>
185− <keyword>infix</keyword>
186− <keyword>infixl</keyword>
187− <keyword>infixr</keyword>
188− <keyword>prefix</keyword>
189− <keyword>instance</keyword>
190− <keyword>let</keyword>
191− <keyword>module</keyword>
192− <keyword>of</keyword>
193− <keyword>if</keyword>
194− <keyword>else</keyword>
195− <keyword>then</keyword>
196− <keyword>where</keyword>
197− <keyword>with</keyword>
198− <keyword>type</keyword>
199− <keyword>proof</keyword>
200− <keyword>tactics</keyword>
201− <keyword>static</keyword>
202− <keyword>impossible</keyword>
203− <keyword>total</keyword>
204− <keyword>assert_total</keyword>
207− <context id="tactic" style-ref="tactic">
208− <keyword>rewrite</keyword>
209− <keyword>exact</keyword>
210− <keyword>intros</keyword>
211− <keyword>intro</keyword>
212− <keyword>refine</keyword>
213− <keyword>trivial</keyword>
214− <keyword>focus</keyword>
215− <keyword>try</keyword>
216− <keyword>compute</keyword>
217− <keyword>solve</keyword>
218− <keyword>attack</keyword>
219− <keyword>refl</keyword>
220− <keyword>state</keyword>
221− <keyword>term</keyword>
222− <keyword>undo</keyword>
223− <keyword>qed</keyword>
224− <keyword>abandon</keyword>
229− <context ref="line-comment"/>
230− <context ref="block-comment"/>
231− <context ref="keyword"/>
232− <context ref="tactic" />
233− <context ref="variable"/>
234− <context ref="type-or-constructor"/>
235− <context ref="keysymbol"/>
236− <context ref="symbol"/>
237− <context ref="string"/>
238− <context ref="char"/>
239− <context ref="float"/>
240− <context ref="decimal"/>
244− <context id="idris" class="no-spell-check">
246− <context ref="c:if0-comment"/>
247− <context ref="c:include"/>
248− <context ref="c:preprocessor"/>
249− <context ref="body"/>
contribs/idriscasesplit.vimdeleted−100
@@ -1,100 +0,0 @@
2− let file = expand("%")
3− let tc = system("idris --client :l " . file)
10−function IdrisShowType()
12− let word = expand("<cword>")
13− let tc = IdrisReload()
17− let ty = system("idris --client :t " . word)
23−function IdrisCaseSplit()
24− let view = winsaveview()
26− let cline = line(".")
27− let word = expand("<cword>")
28− let tc = IdrisReload()
31− let fn = "idris --client :cs! " . cline . " " . word
32− let result = system(fn)
33− if (! (result is ""))
37− call winrestview(view)
42−function IdrisMakeWith()
43− let view = winsaveview()
45− let cline = line(".")
46− let word = expand("<cword>")
47− let tc = IdrisReload()
50− let fn = "idris --client :mw! " . cline . " " . word
51− let result = system(fn)
52− if (! (result is ""))
56− call winrestview(view)
62−function IdrisAddClause()
63− let view = winsaveview()
65− let cline = line(".")
66− let word = expand("<cword>")
67− let tc = IdrisReload()
70− let fn = "idris --client :ac! " . cline . " " . word
71− let result = system(fn)
72− if (! (result is ""))
76− call winrestview(view)
84− let tc = IdrisReload()
86− let expr = input ("Expression: ")
87− let fn = "idris --client '" . expr . "'"
88− let result = system(fn)
94−map <LocalLeader>t :call IdrisShowType()<ENTER>
95−map <LocalLeader>r :call IdrisReload()<ENTER>
96−map <LocalLeader>c :call IdrisCaseSplit()<ENTER>
97−map <LocalLeader>d ?:<ENTER>b:call IdrisAddClause()<ENTER>w
98−map <LocalLeader>w 0:call IdrisMakeWith()<ENTER>
99−map <LocalLeader>e :call IdrisEval()<ENTER>
contribs/idrislang.stydeleted−208
@@ -1,208 +0,0 @@
1−%% --------------------------------------------------- [ Idris Styling Package ]
3−%% A set of LaTeX macros and styling for working with Idris in LaTeX
5−%% + Provides a listings bindings:
6−%% + idris :: default ascii
7−%% + literateidris :: convert ascii maths to math symbols.
8−%% + Defines a `numbers' and `default' listings style.
9−%% + Defines a `code' environment for typesetting idris.
10−%% + \begin{code}[...] ... \end{code}
11−%% + Defines an input command for externally defined idris files.
12−%% + \inputIdrisListing[...]{file.idr}
13−%% + Defines commands typesetting the name Idris.
18−%% - literate :: turn on literate idris for code environments.
19−%% - numbers :: turn on numbers for code environments.
21−%% ----------------------------------------------------------- [ Begin Package ]
22−\ProvidesPackage{idrislang}
24−\RequirePackage{ifthen}
25−\RequirePackage{listings}
26−\RequirePackage{xspace}
27−%% ----------------------------------------------------------------- [ Options ]
29−\setboolean{literate}{false}
31−\setboolean{numbers}{false}
33−\DeclareOption{literate}{%
34− \setboolean{literate}{true}
37−\DeclareOption{numbers}{%
38− \setboolean{numbers}{true}
43−%% ---------------------------------------------------------------- [ Commands ]
44−\newcommand{\Idris}{\textsc{Idris}\xspace}
45−\newcommand{\idris}{\textsc{Idris}\xspace}
47−%% --------------------------------------------------- [ Define Idris Listings ]
48−\lstdefinelanguage{idris}{%
50−%% ----------------------------------------------------------- [ Default Style ]
51− xleftmargin=\parindent,
53− basicstyle=\ttfamily,
54− flexiblecolumns=false,
55− commentstyle=\footnotesize\sffamily,
56−%% ---------------------------------------------------------------- [ Keywords ]
57−%% From Idris Parser and idris-mode and vimscript
59− abstract, attack, case, compute, do, dsl, else, exact, focus, if,
60− import, in, infix, infixl, infixr, instance, intros, module,
61− mutual, namespace, of, let, parameters, partial, pattern, prefix,
62− private, public, refine, rewrite, solve, syntax, term, then,
63− total, trivial, try, using, where, with
65−%% ------------------------------------------------------- [ Prelude Functions ]
67−%% find lib/ -name "*.idr" | xargs grep -e "^[a-zA-Z0-9]* :" | awk -F : '{printf $2", "}'
69− class, data, instance, record, dsl, postulate, default, assert_total,
70− lambda, variable, index_first, index_next
71− % trace, unsafePerformPrimIO, FInt, FChar, FByte, FShort, FLong,
72− % FBits8, FBits16, FBits32, FBits64, FBits8x16, FBits16x8,
73− % FBits32x4, FBits64x2, interpFTy, ForeignTy, mkForeignPrim,
74− % mkLazyForeignPrim, liftPrimIO, fork, unsafePerformIO, listens,
75− % censor, Writer, liftReaderT, asks, Reader, modify, gets, State,
76− % RWS, nGTSm, decideNatLTE, lte, vectInjective1, vectInjective2,
77− % run, myID, send, msgWaiting, recv, recvWithSender, create,
78− % sendToThread, checkMsgs, getMsg, viewB8x16, viewB16x8, viewB32x4,
79− % viewB64x2, pow, exp, log, pi, sin, cos, tan, asin, acos, atan,
80− % atan2, sinh, cosh, tanh, sqrt, floor, ceiling, count, countFrom,
81− % curry, uncurry, uniformB8x16, uniformB16x8, uniformB32x4,
82− % uniformB64x2, putStr, putStrLn, print, getLine, putChar, getChar,
83− % fopen, openFile, closeFile, fread, fwrite, feof, ferror, nullPtr,
84− % nullStr, validFile, while, readFile, userSuppliedName, seq, try,
85− % mkPair, getUName, unApply, mkApp, binderTy, divCeil, nextPow2,
86− % nextBytes, machineTy, bitsUsed, natToBits, getPad, pad8, pad16,
87− % pad32, pad64, shiftLeft, shiftRightLogical, shiftRightArithmetic,
88− % and, or, xor, plus, minus, times, sdiv, udiv, srem, urem, lt, lte,
89− % eq, gte, gt, complement, zeroExtend, intToBits, bitsToInt, bitAt,
90− % getBit, setBit, unsetBit, bitsToStr, findElem, replaceElem,
91− % replaceByElem, mapElem, anyNilAbsurd, anyElim, any, negAnyAll,
92− % notAllHere, notAllThere, all, length, index, weaken, take, toList,
93− % fromList, replicate, foldl, foldr, map, pad, zeroBoundIsEmpty,
94− % empty, insert, delete, contains, fromList, toList, applyKleisli,
95− % applyMor, applyEndo, absZ, negZ, negNat, minusNatZ, plusZ, subZ,
96− % multZ, fromInt, natPlusZPlus, natMultZMult, doubleNegElim,
97− % posInjective, negSInjective, posNotNeg, plusZeroLeftNeutralZ,
98− % plusZeroRightNeutralZ, plusCommutativeZ, modBin, modComp, div,
99− % rem, intToMod, modToStr, branch4, branch5, branch6, branch7,
100− % merge1, merge2, merge3, treeLookup, treeInsert, delType,
101− % treeDelete, treeToList, empty, lookup, insert, delete, fromList,
102− % toList, getWitness, getProof, FalseElim, replace, sym, trans,
103− % lazy, par, malloc, Not, id, the, const, fst, snd, flip, cong,
104− % boolElim, not, intToBool, boolOp, div, mod, strHead, strTail,
105− % strCons, strIndex, reverse, null, getArgs, getEnv, setEnv,
106− % unsetEnv, getEnvironment, exit, usleep, sequence, toHexDigit,
107− % b8ToString, b16ToString, b32ToString, b64ToString, tail, head,
108− % last, init, index, deleteAt, replaceAt, take, drop, fromList,
109− % replicate, zipWith, zip, unzip, concat, elemBy, elem, lookupBy,
110− % lookup, hasAnyBy, hasAny, find, findIndex, elemIndexBy, elemIndex,
111− % nubBy, nub, isPrefixOfBy, isPrefixOf, isSuffixOfBy, isSuffixOf,
112− % catMaybes, diag, range, isLeft, isRight, choose, either, lefts,
113− % rights, partitionEithers, fromEither, maybeToEither, strM, unpack,
114− % pack, span, break, split, ltrim, trim, words, lines, foldr1,
115− % unwords, length, realPart, imagPart, mkPolar, cis, magnitude,
116− % phase, conjugate, isNothing, isJust, maybe, fromMaybe, toMaybe,
117− % justInjective, lowerMaybe, raiseToMaybe, isNil, isCons, head,
118− % tail, last, init, take, drop, takeWhile, dropWhile, list, length,
119− % repeat, replicate, zipWith, zipWith3, zip, zip3, unzip, unzip3,
120− % mapMaybe, toList, reverse, intersperse, intercalate, elemBy, elem,
121− % lookupBy, lookup, hasAnyBy, hasAny, find, findIndex, findIndices,
122− % elemIndexBy, elemIndex, elemIndicesBy, elemIndices, filter, nubBy,
123− % nub, span, break, split, partition, isPrefixOfBy, isPrefixOf,
124− % isSuffixOfBy, isSuffixOf, sorted, mergeBy, merge, sort,
125− % maybeToList, listToMaybe, catMaybes, appendNilRightNeutral,
126− % appendAssociative, lengthAppend, mapPreservesLength,
127− % mapDistributesOverAppend, mapFusion, hasAnyByNilFalse,
128− % hasAnyNilFalse, fromIntegerNat, toIntegerNat, hyper, log2, gcd,
129− % liftA, liftA2, liftA3, guard, when, finToNat, finToInt, weaken,
130− % strengthen, last, natToFin, integerToFin, fromInteger, flatten,
131− % return, isUpper, isLower, isAlpha, isDigit, isAlphaNum, isSpace,
132− % isNL, toUpper, toLower, isHexDigit, isValidHeap, merge, insert,
133− % findMinimum, deleteMinimum, toList, fromList, sort, main, foldl,
134− % concat, concatMap, and, or, any, all, sum, product, Vars,
135− % getAction, setInfo, getInfo, lift, output, queryVars, postVars,
136− % cookieVars, queryVar, getOutput, getHeaders, flushHeaders, flush,
137− % getVars, getContent, getCgiEnv, runCGI, mult
139−%% ---------------------------------------------------------------- [ Comments ]
141− morecomment=[n]{\{-}{-\}}
142−}[keywords,comments,strings]%
144−%% ---------------------------------------- [ Define Idris with Literate Stuff ]
145−\lstdefinelanguage{literateidris}[]{idris}{
146− literate= {+}{{$+$}}1
153− {\\\\}{{\char`\\\char`\\}}1
154− {->}{{$\rightarrow$}}2
156− {<-}{{$\leftarrow$}}2
158− {=>}{{$\Rightarrow$}}2
166−%% -------------------------------------------------- [ Default Listings Style ]
168−\lstdefinestyle{default}{%
169− xleftmargin=\parindent,
171− basicstyle=\ttfamily
173−\lstdefinestyle{numbers}{%
174− xleftmargin=\parindent,
178− numberstyle=\footnotesize\sffamily,
182−%% ------------------------------------------------------ [ A Code Environment ]
183−%% Replicate the existence of literate haskell code environments,
184−%% option to make pretty with numbers.
185−\lstnewenvironment{code}[1][]
186− {\ifthenelse{\boolean{literate}}{%
187− \lstset{language=literateidris}}{%
188− \lstset{language=idris}}
189− \ifthenelse{\boolean{numbers}}{%
190− \lstset{style=numbers, #1}}{%
191− \lstset{style=default, #1}}
194−%% ---------------------------------------------------------- [ Input Listings ]
195−%% Command to add externally defined Idris code to the document.
196−\newcommand{\inputIdrisListing}[2][]{%
198− \ifthenelse{\boolean{literate}}{%
199− \lstset{language=literateidris}}{%
200− \lstset{language=idris}}
201− \ifthenelse{\boolean{numbers}}{%
202− \lstset{style=numbers}}{%
203− \lstset{style=default}}
204− \lstinputlisting[#1]{#2}
208−%% --------------------------------------------------------------------- [ EOF ]
contribs/lib/SQLite3/Makefiledeleted−16
@@ -1,16 +0,0 @@
1−# This makefile compiles the project
6−sqltest : testunit.idr Sqlite3.idr sqlite3api.o
7− idris testunit.idr -o sqltest
9−sqlite3api.o : sqlite3api.c
12−sqlite3api.so: sqlite3api.c
13− gcc -fPIC -o sqlite3api.so -shared sqlite3api.c
15−all : sqltest sqlite3api.o
contribs/lib/SQLite3/Sqlexpr.idrdeleted−278
@@ -1,278 +0,0 @@
4−-----------------------------------------------------------------------------
7−-- Copyright : (c) The University of St Andrews, 2012
9−-- Implementations for SQLite query data type.
11−-----------------------------------------------------------------------------
14−-----------------------------------------------------------
16−-----------------------------------------------------------
24−--Perhaps could extend this by adding
25−-- a dot operator to allow mapping
26−-- between table and column and
27−-- comparing different table columns.
29−data Cond = Equals Value Value
36−data SelVar = Cols (List String)
39−data ColType = CInt String -- parsed as string "int"
45− data Clause = MkCond Cond
51− data condClause = SET Clause
52− | WHERE condClause Clause
54− data Constr = NOTNULL
63− data SQL = SELECT SelVar SQL Clause
65− | INSERT SQL (List Value)
66− | INSERTC SQL (List Value) (List Value)
67− | UPDATE SQL condClause
68− | CREATE SQL (List (Value, ColType , Constr))
70−-- remember to remove these funcs later
71−-- foldr1 : (a -> a -> a) -> List a -> a
73−-- foldr1 f (x::xs) = f x (foldr1 f xs)
76−-- unwords' : List (List Char) -> List Char
78−-- unwords' ws = (foldr1 addSpace ws)
80−-- addSpace : List Char -> List Char -> List Char
81−-- addSpace w s = w ++ (' ' :: s)
84−-- unwords : List String -> String
85−-- unwords = pack . unwords' . map unpack
87−-----------------------------------------------------------
88−-- | This function replaces values with question mark
89−-- following by an index number. It then puts the value
90−-- replaced, in the list.
91−-----------------------------------------------------------
93−valString : List (Maybe (Int, Value)) -> Value -> (String, List (Maybe (Int, Value)))
94−valString xs (VInt x) = ("?" ++ show (cast (length xs) + 1), xs ++ [Just (cast ((length xs) + 1), (VInt x))])
95−valString xs (VStr x) = ("?" ++ show (cast (length xs) + 1), xs ++ [Just (cast ((length xs) + 1), (VStr x))])
96−valString xs (VFloat x) = ("?" ++ show (cast (length xs) + 1), xs ++ [Just (cast ((length xs) + 1), (VFloat x))])
97−valString xs (VCol n) = (n, xs)
99−-----------------------------------------------------------
100−-- | This function calls valString on a list of Values
101−-- and separates the values by commas.
102−-----------------------------------------------------------
104−listVal : List (Maybe (Int, Value)) -> List Value -> (String, List (Maybe (Int, Value)))
105−listVal xs [] = ("", xs)
106−listVal xs (v::vs) = let (str, newxs) = (valString xs v) in
107− let (str', newxs') = listVal newxs vs in
108− (unwords (intersperse "," (words (str) ++ words (str'))), newxs')
110−-----------------------------------------------------------
111−-- | Parses the type of column to be created.
112−-----------------------------------------------------------
114−getColType : List (Maybe (Int, Value)) -> ColType -> (String, List (Maybe (Int, Value)))
115−getColType xs (CInt x) = ("int", xs)
116−getColType xs (Varchar str) = ("varchar(255)", xs)
118−-----------------------------------------------------------
119−-- | CREATE Constraints
120−-----------------------------------------------------------
122−getConstr : List (Maybe (Int, Value)) -> Constr -> (String, List (Maybe (Int, Value)))
123−getConstr xs (NOTNULL) = ("NOT NULL", xs)
124−getConstr xs (UNIQUE constr) = ("NOT NULL UNIQUE", xs)
125−getConstr xs (PRIMARYKEY) = ("PRIMARY KEY", xs)
126−getConstr xs (FOREIGNKEY) = ("FOREIGN KEY", xs)
127−getConstr xs (CHECK) = ("CHECK", xs)
128−getConstr xs (DEFAULT) = ("DEFAULT", xs)
129−getConstr xs (None) = ("", xs)
131−putBrackets : String -> String
132−putBrackets str = "(" ++ str ++ ")"
134−-----------------------------------------------------------
135−-- | Used to detect a complex type in a nested SQLite query
136−-- This function is used for bracketing the nested queries.
137−-----------------------------------------------------------
138−complexType : SQL -> Bool
139−complexType (TBL tbl) = False
140−complexType (SELECT vars sql c) = True
142−-----------------------------------------------------------
144−-----------------------------------------------------------
146−listValType : List (Maybe (Int, Value)) -> List (Value, ColType , Constr) -> (String, List (Maybe (Int, Value)))
147−listValType xs [] = ("", xs)
148−listValType xs ((val, types, constr) :: vs) =
149− let (str , newxs) = valString xs val in
150− let (str' , newxs') = getColType newxs types in
151− let (str'', newxs'') = getConstr newxs' constr in
152− let (finalstr, finalxs) = listValType newxs'' vs in
153− (unwords (intersperse " " (words str ++ words str' ++ words str'' ++ words finalstr)) , finalxs)
156−-----------------------------------------------------------
157−-- | Evaluates a conditional WHERE clause
158−-----------------------------------------------------------
160−evalCond : List (Maybe (Int, Value)) -> Cond -> (String, List (Maybe (Int, Value)))
161−evalCond xs (Equals val1 val2) = let (restring , newxs ) = valString xs val1 in
162− let (restring2, newxs') = valString newxs val2 in
163− (restring ++ " = " ++ restring2, newxs')
165−evalCond xs (MkGT val1 val2) = let (restring , newxs ) = valString xs val1 in
166− let (restring2, newxs') = valString newxs val2 in
167− (restring ++ " > " ++ restring2, newxs')
169−evalCond xs (MkGTE val1 val2) = let (restring , newxs ) = valString xs val1 in
170− let (restring2, newxs') = valString newxs val2 in
171− (restring ++ " >= " ++ restring2, newxs')
173−evalCond xs (MkLT val1 val2) = let (restring , newxs ) = valString xs val1 in
174− let (restring2, newxs') = valString newxs val2 in
175− (restring ++ " < " ++ restring2, newxs')
177−evalCond xs (MkLTE val1 val2) = let (restring , newxs ) = valString xs val1 in
178− let (restring2, newxs') = valString newxs val2 in
179− (restring ++ " =< " ++ restring2, newxs')
181−evalCond xs (MkNULL val) = let (restring , newxs ) = valString xs val in
182− (restring ++ " IS NULL " , newxs)
185−-----------------------------------------------------------
186−-- | Evaluates clauses
187−-- Supports WHERE Clause
188−-- WHERE Clause And Another-Clause
189−-- WHERE Clause Or Another-Clause
190−-----------------------------------------------------------
191−clauseString : List (Maybe (Int, Value)) -> Clause -> (String, List (Maybe (Int, Value)))
193−clauseString xs (Empty) = ("" , []) -- No condition
194−clauseString xs (MkCond cond') = let (condstr, newxs) = evalCond xs cond' in
197−clauseString xs (AND c1 c2) = let (clausestr, newxs) = clauseString xs c1 in
198− let (clausestr2, newxs') = clauseString newxs c2 in
199− (clausestr ++ " AND " ++ clausestr2 , newxs')
201−clauseString xs (OR c1 c2) = let (clausestr, newxs) = clauseString xs c1 in
202− let (clausestr2, newxs') = clauseString newxs c2 in
203− (clausestr ++ " OR " ++ clausestr2 , newxs')
206−-----------------------------------------------------------
207−-- | Evaluates conditional clauses.
208−-----------------------------------------------------------
210−condClauseStr : List (Maybe (Int, Value)) -> condClause -> (String, List (Maybe (Int, Value)))
211−condClauseStr xs (SET setcl) = let (condstr, newxs) = clauseString xs setcl in
212− (" SET " ++ condstr, newxs)
214−condClauseStr xs (WHERE setcl1 setcl2) = let (condstr, newxs) = condClauseStr xs setcl1 in
215− let (condstr', newxs') = clauseString newxs setcl2 in
216− ( condstr ++ " WHERE " ++ condstr', newxs')
219−-----------------------------------------------------------
220−-- | Evaluates queries by calling the other functions
221−-- on each part of the query
222−-----------------------------------------------------------
223−evalSQL : List (Maybe (Int, Value)) -> SQL -> (String, List (Maybe (Int, Value)))
224−-- SELECT data from tbl1 where num > (SELECT num from tbl1 where num = 24)
225−-- evalSQL [] ((SELECT ALL)(TBL "tbl")(MkSQL ((SELECT ALL) (TBL "tbl")(MkCond (VCol "))))
227−--clauseString xs (MkSQL sql) = (evalSQL xs sql)
229−-- Separate list of tables
230−-- For complex type, return list returned by evalSQL
232−evalSQL xs (TBL tbl) = (unwords (intersperse "," ( tbl)), xs)
233−evalSQL xs (SELECT vars sql' c) =
234− let (sqlstring, newxs) = evalSQL xs sql' in
235− let (csstring, newxs') = clauseString newxs c in
237− Empty => case vars of
238− ALL => if complexType sql'
239− then ("SELECT " ++ "*" ++ " FROM " ++
240− putBrackets sqlstring ++ csstring, newxs)
241− else ("SELECT " ++ "*" ++ " FROM " ++ sqlstring ++
243− Cols selvar => if complexType sql'
244− then ("SELECT " ++ unwords selvar ++
245− " FROM " ++ putBrackets sqlstring ++ csstring, newxs)
246− else ("SELECT " ++ unwords selvar ++ " FROM " ++ sqlstring ++
249− ALL => if complexType sql'
250− then ("SELECT " ++ "*" ++ " FROM " ++
251− " WHERE " ++ csstring, newxs)
252− else ("SELECT " ++ "*" ++ " FROM " ++ sqlstring
253− ++ " WHERE " ++ csstring, newxs')
254− Cols selvar => if complexType sql'
255− then ("SELECT " ++ (unwords selvar) ++ " FROM " ++
256− putBrackets sqlstring ++ " WHERE " ++
258− else ("SELECT " ++ (unwords selvar) ++ " FROM " ++ sqlstring ++
259− " WHERE " ++ csstring, newxs')
262−evalSQL xs (INSERT sql vals) = let (tblname, newvals) = evalSQL xs sql in
263− let (str, newxs ) = listVal newvals vals in
264− ("INSERT INTO " ++ tblname ++ " VALUES (" ++ str ++ ")", newxs)
266−evalSQL xs (INSERTC sql cols vals) = let (tblname, newvals) = evalSQL xs sql in
267− let (strcol, newcol) = listVal newvals cols in
268− let (strval, newcolval) = listVal newcol vals in
269− ("INSERT INTO " ++ tblname ++ "(" ++ strcol ++ ")" ++ "VALUES (" ++ strval ++ ")", newcolval)
272−evalSQL xs (UPDATE sql cl) = let (tblname, newxs) = evalSQL xs sql in
273− let (csstring, newxs') = condClauseStr newxs cl in
274− ("UPDATE " ++ tblname ++ csstring, newxs')
276−evalSQL xs (CREATE sql details) = let (sqlstring, newxs) = evalSQL xs sql in
277− let (csstring, newxs') = listValType newxs details in
278− ("CREATE TABLE " ++ sqlstring ++ "(" ++ csstring ++ ")", newxs')
contribs/lib/SQLite3/Sqlite3.idrdeleted−425
@@ -1,425 +0,0 @@
7−%include C "sqlite3api.h"
9−-----------------------------------------------------------------------------
12−-- Copyright : (c) The University of St Andrews, 2012
14−-- Library built on top of FFI supporting basic SQLite C/C++ Interface
17−-----------------------------------------------------------------------------
19−-- | The types supported by Idris returned by the database functions.
21−data DBVal = DBInt Int
27−data DBPointer = MkDBPointer Ptr
29−data TBPointer = MkTBPointer Ptr
31−data StmtPtr = MkStmtPtr Ptr
34−Table = List (List DBVal)
36−-- ForMap used in to_list_v1
37−forM : Applicative f => List a -> (a -> f b) -> f (List b)
38−forM xs f = (sequence (map f xs))
40−-- Neater error handling done using DB
41−data DB a = MkDB (IO (Either String a))
43−instance Functor DB where
44− map f (MkDB action) = MkDB (do res <- action
48−instance Applicative DB where
49− pure = MkDB . return . Right
50− (MkDB f) <$> (MkDB x) = MkDB (do f' <- f
52− Left err => return (Left err)
53− Right op => x >>= (return . map op))
56−instance Monad DB where
57− (MkDB l) >>= k = MkDB (do c <- l
59− Left err => return (Left err)
60− Right v => case k v of
62− return x = MkDB (return (Right x))
65−fail err = MkDB (return (Left err))
68−liftIO f = MkDB (do f' <- f
71−ioError : String -> IO a
72−ioError err = do putStrLn err
73− return (believe_me ())
76−runDB (MkDB f) = do f' <- f
79− Left str => ioError str
81−-----------------------------------------------------------------------------
82−-- | Opens an SQLite database file as specified by the String name argument.
83−-----------------------------------------------------------------------------
85−open_db : String -> DB DBPointer
86−open_db name = do x <- liftIO (mkForeign (FFun "sqlite3_open_idr" [FString] FPtr) name)
87− return (MkDBPointer x)
89−-----------------------------------------------------------------------------
90−-- | Destructor for the DBPointer.
91−-----------------------------------------------------------------------------
93−close_db : DBPointer -> DB Int
94−close_db (MkDBPointer pointer) = liftIO (mkForeign (FFun "sqlite3_close_idr" [FPtr] FInt) pointer)
96−-----------------------------------------------------------------------------
97−-- | Wrapper around prepare, step and finalize.
98−-----------------------------------------------------------------------------
100−exec_db : DBPointer -> String -> DB Int
101−exec_db (MkDBPointer pointer) stmt = do
102− x <- liftIO (mkForeign (FFun "sqlite3_exec_idr" [FPtr, FString] FInt) pointer stmt)
104− then fail "Could not execute."
107−-----------------------------------------------------------------------------
108−-- | Executes a prepared query. Use of this version is recommended.
109−-----------------------------------------------------------------------------
111−exec_db_v2 : StmtPtr -> DB Int
112−exec_db_v2 (MkStmtPtr pointer) = do
113− x <- liftIO (mkForeign (FFun "exec_db" [FPtr] FInt) pointer)
115− then fail "No data returned."
118−-----------------------------------------------------------------------------
119−-- | Returns the error stored in the buffer by exec_db function.
120−-- This function can only be used with exec_db and get_table.
121−-- Only these functions store any occured error in the buffer array.
122−-----------------------------------------------------------------------------
124−get_error : DBPointer -> IO String
125−get_error (MkDBPointer pointer) = mkForeign (FFun "sqlite3_get_error" [FPtr] FString) pointer
128−-----------------------------------------------------------------------------
129−-- | Compiles the query inot a byte-code program in order to execute it.
130−-- Returns a pointer to a Statement pointer on a successful call.
131−-- Returns a null pointer on a failure.
132−-----------------------------------------------------------------------------
134−prepare_db : DBPointer -> String -> DB StmtPtr
135−prepare_db (MkDBPointer pointer) cmd = do
136− result <- liftIO (mkForeign (FFun "sqlite3_prepare_idr" [FPtr, FString] FPtr) pointer cmd)
137− flag <- liftIO (nullPtr result)
139− then fail "Error occured while preparing"
140− else return (MkStmtPtr result)
142−-----------------------------------------------------------------------------
143−-- | Returns the error stored in the buffer by exec_db function.
144−-- This function can only be used with exec_db and get_table.
145−-- Only these functions store any occured error in the buffer array.
146−-----------------------------------------------------------------------------
148−step_db : StmtPtr -> DB Int
149−step_db (MkStmtPtr pointer)= do
150− x <- liftIO (mkForeign (FFun "sqlite3_step_idr" [FPtr] FInt)pointer)
152− then fail "SQLITE_DONE"
155−-----------------------------------------------------------------------------
156−-- | Deletes a prepared statement. This function must be called after
158−-----------------------------------------------------------------------------
160−finalize_db : StmtPtr -> DB Int
161−finalize_db (MkStmtPtr pointer) = do
162− x <- liftIO (mkForeign (FFun "sqlite3_finalize_idr" [FPtr] FInt) pointer)
164− then fail "Could not finalize"
167−-----------------------------------------------------------------------------
168−-- | Resets a prepared statement pointer back to its initial state.
169−-----------------------------------------------------------------------------
171−reset_db : StmtPtr -> DB Int
172−reset_db (MkStmtPtr pointer) = do
173− x <- liftIO (mkForeign (FFun "sqlite3_reset_idr" [FPtr] FInt) pointer)
175− then fail "Could not reset"
178−-----------------------------------------------------------------------------
179−-- | These routines obtain column information.
180−-----------------------------------------------------------------------------
182−column_count : DBPointer -> IO (Either String Int)
183−column_count (MkDBPointer pointer) = do
184− x <- mkForeign (FFun "sqlite3_column_count_idr" [FPtr] FInt) pointer
185− return $ if (x == 0 )
189−column_name : DBPointer -> Int -> IO String
190−column_name (MkDBPointer pointer) iCol =
191− mkForeign (FFun "sqlite3_column_name_idr" [FPtr, FInt] FString) pointer iCol
193−column_decltype : DBPointer -> Int -> IO String
194−column_decltype (MkDBPointer pointer) iCol =
195− mkForeign (FFun "sqlite3_column_decltype_idr" [FPtr, FInt] FString) pointer iCol
198−column_bytes : DBPointer -> Int -> IO Int
199−column_bytes (MkDBPointer pointer) iCol =
200− mkForeign (FFun "sqlite3_column_bytes_idr" [FPtr, FInt] FInt) pointer iCol
203−column_blob : DBPointer -> Int -> IO String
204−column_blob (MkDBPointer pointer) iCol =
205− mkForeign (FFun "sqlite3_column_bytes_idr" [FPtr, FInt] FString) pointer iCol
208−column_text : DBPointer -> Int -> IO String
209−column_text (MkDBPointer pointer) iCol =
210− mkForeign (FFun "sqlite3_column_text_idr" [FPtr, FInt] FString) pointer iCol
213−column_Int : DBPointer -> Int -> IO Int
214−column_Int (MkDBPointer pointer) iCol =
215− mkForeign (FFun "sqlite3_column_int_idr" [FPtr, FInt] FInt) pointer iCol
217−-----------------------------------------------------------------------------
218−-- | These routines support some of SQLite backup functions.
219−-----------------------------------------------------------------------------
221−backup_init : DBPointer -> String -> DBPointer -> String -> IO DBPointer
222−backup_init (MkDBPointer des_pointer) destName (MkDBPointer src_pointer) srcName =
223− do x <- mkForeign (FFun "sqlite3_backup_init_idr" [FPtr,FString, FPtr, FString] FPtr)
224− des_pointer destName src_pointer srcName
225− return (MkDBPointer x)
227−backup_step : DBPointer -> Int -> IO Int
228−backup_step (MkDBPointer pointer) nPage =
229− mkForeign (FFun "sqlite3_backup_step_idr" [FPtr, FInt] FInt) pointer nPage
231−backup_finish : DBPointer -> IO Int
232−backup_finish (MkDBPointer pointer) =
233− mkForeign (FFun "sqlite3_backup_finish_idr" [FPtr] FInt) pointer
235−backup_remaining : DBPointer -> IO Int
236−backup_remaining (MkDBPointer pointer) =
237− mkForeign (FFun "sqlite3_backup_remaining_idr" [FPtr] FInt) pointer
240−-----------------------------------------------------------------------------
241−-- | Use of this interface is not recommended.
242−-- This function returns a result table. The functions num_row and num_col
243−-- are used to obtain the number of rows and columns.
244−-- These functions can be used to print the resulting table.
245−-----------------------------------------------------------------------------
247−get_table : DBPointer -> String -> DB TBPointer
248−get_table (MkDBPointer pointer) name = do
249− x <- liftIO(mkForeign (FFun "sqlite3_get_table_idr" [FPtr, FString] FPtr) pointer name)
250− flag <- liftIO (nullPtr x)
252− then do x <- liftIO(get_error_table pointer) ; fail x
253− else return (MkTBPointer x)
255− get_error_table : Ptr-> IO String
256− get_error_table pointer = do x <- mkForeign (FFun "sqlite3_get_error" [FPtr] FString) pointer
260−free_table : TBPointer -> IO ()
261−free_table (MkTBPointer pointer) = do x <- mkForeign (FFun "sqlite3_free_table_idr" [FPtr] FUnit) pointer
264−-----------------------------------------------------------------------------
265−-- | This version of these function obtain the row and column number
266−-- from the Table struct. These functions are only used with get_table.
267−-----------------------------------------------------------------------------
269−num_row : TBPointer -> IO Int
270−num_row (MkTBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_row" [FPtr] FInt) pointer
273−num_col : TBPointer -> IO Int
274−num_col (MkTBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_col" [FPtr] FInt) pointer
277−-----------------------------------------------------------------------------
278−-- | This version of these function obtain the row and column number
279−-- from the Database struct.
280−-----------------------------------------------------------------------------
282−num_row_v2 : DBPointer -> IO Int
283−num_row_v2 (MkDBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_row_v2" [FPtr] FInt) pointer
286−num_col_v2 : DBPointer -> IO Int
287−num_col_v2 (MkDBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_col_v2" [FPtr] FInt) pointer
290−-----------------------------------------------------------------------------
291−-- | This function prints the result of a query by checking the type
292−-- of each value returned, it then calls the appropriate function.
293−-- Ther result is one of the DBVal variants.
294−-----------------------------------------------------------------------------
296−get_data : DBPointer -> Int -> Int -> IO DBVal
297−get_data (MkDBPointer pointer) row col = do
298− ty <- get_data_type pointer row col
300− where get_data_type : Ptr ->Int -> Int -> IO Int
301− get_data_type pointer row col =
302− mkForeign (FFun "sqlite3_get_data_type" [FPtr, FInt, FInt] FInt) pointer row col
303− get_data_val_int : Ptr -> Int -> IO Int
304− get_data_val_int pointer col =
305− mkForeign (FFun "sqlite3_get_val_int" [FPtr,FInt] FInt) pointer col
307− get_data_val_text : Ptr -> Int -> IO String
308− get_data_val_text pointer col =
309− mkForeign (FFun "sqlite3_get_val_text" [FPtr, FInt] FString) pointer col
311− get_data_val_float : Ptr -> Int -> IO Float
312− get_data_val_float pointer col =
313− mkForeign (FFun "sqlite3_get_float" [FPtr, FInt] FFloat) pointer col
315− helper : Int -> IO DBVal
316− helper 1 = do i <- get_data_val_int pointer col ; return (DBInt i)
317− helper 2 = do i <- get_data_val_float pointer col ; return (DBFloat i)
318− helper 3 = do i <- get_data_val_text pointer col; return (DBText i)
319− helper _ = return DBNull
321−-----------------------------------------------------------------------------
322−-- | This function makes use of get_data to get all the result.
323−-----------------------------------------------------------------------------
325−toList_v1 : DBPointer -> DB Table
326−toList_v1 db = do nbR <- liftIO (num_row_v2 db)
327− nmC <- liftIO (num_col_v2 db)
328− res <- liftIO $ forM [0..(nbR-1)] $ \ i =>
329− forM [0..(nmC-1)] $ \ j => get_data db i j
330− return (the (List (List DBVal)) res)
332−strcat : String -> String-> String
333−strcat str1 str2 = str1 ++ str2
335−-----------------------------------------------------------------------------
336−-- | This version of toList retunrs result from get_table
337−-- This could be removed if not needed in the future.
338−-----------------------------------------------------------------------------
340−--toList_v2 : String -> String -> DBPointer -> DB Table
341−--toList_v2 name stmt x = do
342−-- ptr <- (get_table x (stmt))
343−-- nbR <- liftIO (num_row ptr)
344−-- nmC <- liftIO (num_col ptr)
345−-- res <- forM [0..(nbR-1)] (\ i =>
346−-- forM [0..(nmC-1)] (\ j =>
347−-- liftIO(get_data x name i j)
351−-- liftIO (free_table ptr)
355−-----------------------------------------------------------------------------
356−-- | These routines support binding the types supported by Idris.
357−-- These return a pointer to statement pointer since we want to allow
358−-- binding multiple values by implementing a recursive function.
359−-----------------------------------------------------------------------------
361−bind_int : StmtPtr -> Int -> Int -> DB StmtPtr
362−bind_int (MkStmtPtr pointer) indexval val = do
363− x <- liftIO (mkForeign (FFun "sqlite3_bind_int_idr" [FPtr, FInt, FInt] FPtr) pointer indexval val)
364− flag <- liftIO (nullPtr x)
366− then fail "Could not bind int."
367− else return (MkStmtPtr x)
370−bind_float : StmtPtr -> Int -> Float -> DB StmtPtr
371−bind_float (MkStmtPtr pointer) indexval val = do
372− x <- liftIO (mkForeign (FFun "sqlite3_bind_float_idr" [FPtr, FInt, FFloat] FPtr) pointer indexval val)
373− flag <- liftIO (nullPtr x)
375− then fail "Could not bind float."
376− else return (MkStmtPtr x)
378−bind_text : StmtPtr -> String -> Int -> Int -> DB StmtPtr
379−bind_text (MkStmtPtr pointer) text indexval lengthval = do
380− x <- liftIO (mkForeign (FFun "sqlite3_bind_text_idr" [FPtr, FString, FInt, FInt] FPtr)
381− pointer text indexval lengthval)
382− flag <- liftIO(nullPtr x)
384− then fail "Could not bind text."
385− else return (MkStmtPtr x)
387−bind_null : StmtPtr -> Int -> DB StmtPtr
388−bind_null (MkStmtPtr pointer) indexval = do
389− x <- liftIO (mkForeign (FFun "sqlite3_bind_null_idr" [FPtr, FInt] FPtr) pointer indexval)
390− flag <- liftIO (nullPtr x)
392− then fail "Could not bind null."
393− else return (MkStmtPtr x)
395−-----------------------------------------------------------------------------
397−-----------------------------------------------------------------------------
399−strlen : String -> DB Int
400−strlen str = liftIO (mkForeign (FFun "strLength" [FString] FInt) str)
402−instance Show DBVal where
403− show (DBInt i) = "Int val: " ++ show i ++ "\n"
404− show (DBText i) = "Text val: " ++ show i ++ "\n"
405− show (DBFloat i) = "Float val: " ++ show i ++ "\n"
406− show (DBNull ) = "NULL"
408−-----------------------------------------------------------------------------
409−-- | Multi bind a list of values.
410−-----------------------------------------------------------------------------
412−bindMulti : StmtPtr-> List (Maybe (Int, Value)) -> DB StmtPtr
413−bindMulti pointer [] = return pointer
414−bindMulti pointer (Nothing :: vs) = bindMulti pointer vs
415−bindMulti pointer ((Just (indexs, (VInt i)))::vs) =
416− do x <- bind_int pointer indexs i
418−bindMulti pointer ((Just (indexs, (VStr s)))::vs) =
420− x <- bind_text pointer s indexs len
422−bindMulti pointer ((Just (indexs, (VFloat f)))::vs) =
423− do x <- bind_float pointer indexs f
contribs/lib/SQLite3/newdb.dbdeleted
Binary file not shown.
contribs/lib/SQLite3/somedb.dbdeleted
Binary file not shown.
contribs/lib/SQLite3/sqlite3.texdeleted−157
@@ -1,157 +0,0 @@
1− \documentclass[11pt]{article}
3− \oddsidemargin -0.04cm
4− \evensidemargin -0.04cm
12− \section{Introduction}
14−This document provides overview on how the Idris library for SQLite3 works. The code base is written on top of the
15−SQLite3 C/C++ Interface.
16−This library supports some features of the low-level library, implemented in a higher level basis.
17−The library allows making use of queries as data types. The aim of this library is to avoid
18−SQL injections which are the most common security issues.
19−To avoid this we have defined a datatype which describes queries.
20−The queries are written using these data types and parsed as quoted string
21−while replacing values with \emph{indexed question mark} to be binded with the prepared statement.
22−This prevents the user from preparing the queries inappropriately by not allowing to pass
23−any types of values directly to the prepare function. However this is a design choice, the library
24−does not prevent the user from passing a String directly to the prepare function.
26−\section{Using the library}
27−\label{Using the library}
28−Simple examples have been provided in the \emph{testunit.idr} file.
29−To open a database, use the open\_db function which takes the filename as a string.
30−This function implements the sqlite3\_open function.
31−This function returns a pointer to the database which can be used by other function
32−to access the database object.
33−Whether or not an error occurs when it is opened,
34−resources should be released by passing it to close\_db when it is no longer required.
35−A query can then be builts using the supported data types.
36−The library supports limited number of queries at the moment. The supported sql commands are :
44−\subsection{Creating Queries}
45−\label{Creating Queries}
47−To create a query, use the evalSQL function which takes an empty list and the SQL query.
48−The routine evaluates the expression recrusively by dividing it into smaller parts,
49−filling up the list with the received values. For instance the following is a valid query:
51−let sql = evalSQL [ ] ((SELECT ALL)(TBL ["tbl1"]) (MkCond (MkNULL (VCol "data"))))
53−\newline{This will be parsed as :}
54−\b{“SELECT * FROM tbl1 WHERE data IS NULL “}
56−The evaluator returns a string and a list of indexed values.
57−The string part of the query could be parsed to prepare.
58−\emph{evalSQL} parses the query as a string replacing values with \emph{?} and an index starting from one,
59−storing them in the list given to it as an argument.
63−evalSQL [ ] (SELECT (Cols ["data"]) (SELECT (Cols["num","data"]) (TBL ["tbl1"])
64−\newline (MkCond(Equals(VCol "num")(VInt 2))))Empty))
66−is passed to prepare as :
68−SELECT * FROM tbl1 WHERE data = ?1 AND num = ?2 OR num = ?3
70−and returns the list as follows:
71−\newline{(Just (1, VStr "data0")) ,(Just (2, VInt 1)) , (Just (3, VInt 2))}
73−The values in the list are binded to the statement using bindMulti function.
74−This function takes the statement pointer returned by prepare and the list returned by evalSQL
75−and binds the values by calling the appropriate functions.
77−The function exec\_db\_v2 executes the statement.
78−Note that the other version of exec\_db implements the sqlite3\_exec() interface which is a wrapper
79−around sqlite3\_prepare\_v2(), sqlite3\_step(), and sqlite3\_finalize(),
80−without having to use a lot of code, though the use of this function is not recommended in this case.
82−The functions finalize\_db and close\_db must be called to clean up the open resources.
83−To print the result, the function toList\_v1 can be used which takes a DBPointer and returns
86−\subsection{More Examples}
88−Nested expressions are also supported. You could write queries such as :
90−evalSQL [ ] (SELECT (Cols ["data"]) (SELECT (Cols["num","data"]) (TBL ["tbl1"]) (MkCond (Equals (VCol "num")(VInt 2)))) Empty)
94−SELECT data FROM (SELECT num data FROM tbl1 WHERE num = ?1)
96−Note that in this example, the inner query must include the same column as the outer one otherwise this query will not validate.
98−\subsection{SQL Data Type}
100−The SQL Data Types describe the queries that are supported by the library.
101−The implementation of these datatypes is similar to defining a grammar.
102−Data type Value consists of Int, String and Float.
103−The data type can be extended to further support queries.
104−The evaulator function makes use of smaller function to evaulate parts of the query.
105−For instance given a SELECT qeury, it calls \emph{evalSQL} to obtain the list of tables,
106−and clauseString to evaluate the rest of the expression which could include a WHERE clause or could be Empty.
109−\section{Evaluating Queries}
110−\label{Evaluating Queries}
111−The method used here is a divide and conquer manner which divides the query into smaller
112−parts and deals with each part and puts the results together to return a String representation
113−of the query and a list of values.
114−However this could result to a slow type checking process since it needs to go through all
115−the possibilities to type check. Maybe this can be improved?
117−\subsection{evalSQL Function}
118−\label{evalSQL Function}
119−This is a recursive evaluator which makes a call to itself.
120−An SQL could consist of a SELECT ALL or Columns followed by another SQL
121−which could be a nested query or just the name of the table(s).
122−It then call the appropriate functions to evaluate the query.
123−It returns the well-quoted String expression and a list of indexed values which are passed to the bind function.
124−\section{Pointers passed to Idris functions}
125−\label{Pointers passed to Idris functions}
127−The library uses FFI. In order to make the pointers passed to each function more explicit,
128−we have defined them as data types. For instance open\_db takes a String and returns a DBPointer
129−(Database Pointer) and prepare\_db
130−takes a DBPointer and returns a StmtPtr(Statemenet Pointer).
131−Error handling is done using the \emph {DB a} data type which
132−is either \emph {IO String} indicating an error or \emph{ IO a}.
133−To test the functions in main, you need to use runDB :
135−\centering runDB : DB a $\rightarrow$ IO a
137−More examples on how to use the functions can be found in \emph{testunit.idr}
139−\section{Using the C Functions}
140−\label{Using the C Functions}
141−The library includes some wrapper functions such as get\_table
142−and exec\_db. Using these functions mixed with prepare, step or finalize
143−inappropriately could cause segmentation faults.
144−Perhaps these functions could be removed from the library if no longer required in the future
145−since the main purpose of this library is to make use of data types.
146−However these functionalities could be implemented internally without calling
147−the C Interface wrapper functions.
149−\section{Further improving the library}
150−\label{Further improving the library}
151−There are many features that could be added to this library. These include adding more useful SQL Commands,
152−extending the SQL datatype to support more complex queries and possibly improving \emph{evalSQL}
153−for a faster performance.
154−Another useful thing to implement is the dot operator(.) which is the member access operator to yield
155−the value of a field in a table. This enables comparing values in different tables and constructing
156−more complex queries.
contribs/lib/SQLite3/sqlite3api.cdeleted−543
@@ -1,543 +0,0 @@
5− * Created by Melissa Farinaz MOZIFIAN on 22/06/2012.
6− * Copyright 2012. All rights reserved.
11−#include "sqlite3api.h"
14−// buffer used for storing queries
15−// Used in high-level functions.
16−static char sql_query_buffer[2000];
17−// array used to store the string
18−//value obtain by get_val_text
21− open an SQLite database file as
22− specified by the filename argument.
23− Returns pointer to DB struct on success
26−void* sqlite3_open_idr(const char *filename){
29− int res =sqlite3_open(filename,&db);
31− if(res != SQLITE_OK){
32− printf("Error occured while opening the databse.");
35− DBinfo *dbi = malloc(sizeof(DBinfo));
41− Frees the resource and returns 0 on success
43−int sqlite3_close_idr(void* db){
45− DBinfo* dbi =(DBinfo*) db;
46− int res =sqlite3_close(dbi->db_ptr);
47− if (res == SQLITE_OK){
56− SQLite wrapper around sqlite3_prepare_v2(),
57− sqlite3_step(), and sqlite3_finalize().
58− This version of exec cannot be used with prepare.
59− For executing queries, must use the exec_db function.
61−int sqlite3_exec_idr(void* db, const char *sql)
63− DBinfo* dbi =(DBinfo*) db;
66− rc = sqlite3_exec(dbi->db_ptr,sql,NULL, NULL, &err);
67− if (rc != SQLITE_OK && err != NULL) {
68− strncpy(dbi->buffer, err, sizeof(dbi->buffer));
74− Gets the error store in the buffer
75− in the struct. Some certain functions
76− have the feature to store errors in a buffer.
78−char* sqlite3_get_error(void* db) {
79− DBinfo* dbi =(DBinfo*) db;
83− Compiles the query into a byte-code program
84− Returns a pointer to the sqlite3_stmt pointer
85− and stores it in the struct.
87−void* sqlite3_prepare_idr(void *db,const char *zSql){
91− DBinfo* dbi =(DBinfo*) db;
93− int rec = sqlite3_prepare_v2(dbi->db_ptr,zSql,-1,&stmt,&tail);
95− dbi ->Ptr_tail = tail;
97− if(rec != SQLITE_OK){
103− Another wrapper interface that is preserved
104− for backwards compatibility.
105− Use of this interface is not recommended.
106− This was mainly used for testing within the
109−void* sqlite3_get_table_idr(void* db,
112− DBinfo* dbi =(DBinfo*) db;
115− Table* tbl = malloc(sizeof(Table));
116− tbl->database = dbi;
117− int res = sqlite3_get_table(dbi->db_ptr,sql,&tbl->table_data,&tbl->num_row,&tbl->num_col,&err);
118− int array_size = sizeof(&tbl->table_data);
120− if( res != SQLITE_OK && err != NULL){
121− strncpy(dbi->buffer, err, sizeof(dbi->buffer));
125− tbl -> data_size = array_size;
130− This function executes queries.
131− This can be used after preparing a query
132− In case of error or library misuse
134− It also calls step in order to obtain
135− the row and column number and stores them
136− in the struct. The row number is needed
137− later on in get_data_type function.
141− DBinfo* dbi =(DBinfo*) p;
142− int rc, col, row_counter;
144− const char* col_name;
146− rc = sqlite3_step(dbi->ppStmt);
148− if( rc == SQLITE_DONE){
151− if(rc == SQLITE_ERROR && rc == SQLITE_MISUSE){
156− while (rc == SQLITE_ROW) {
158− rc = sqlite3_step(dbi->ppStmt);
162− col = sqlite3_column_count(dbi->ppStmt);
163− dbi->row_count = row_counter;
164− dbi->col_count = col;
168− Returns row number from DB Struct
171−int sqlite3_get_num_row_v2(void* p){
173− DBinfo* dbi =(DBinfo*) p;
174− int row_number =dbi->row_count;
179− Returns column number from DB Struct
181−int sqlite3_get_num_col_v2(void* p){
183− DBinfo* dbi =(DBinfo*) p;
184− int col_number =dbi-> col_count;
189− Another way of obtaining row number
190− Thought this function gets the value
191− from Table struct. The value is stored
192− in the struct after calling get_table.
193− Using this version is not recommended
194− unless used with get_table
196−int sqlite3_get_num_row(void* p){
198− Table* tbl =(Table*) p;
199− int row_number =tbl->num_row;
204− Another way of obtaining column number
205− Thought this function gets the value
206− from Table struct. The value is stored
207− in the struct after calling get_table.
208− Using this version is not recommended
209− unless used with get_table
211−int sqlite3_get_num_col(void* p){
213− Table* tbl =(Table*) p;
214− int col_number =tbl-> num_col;
219− This routine returns the type of value
220− and must be called after prepare and exec.
221− Since exec steps through database to obtain
222− row number, this function calls reset to
223− set the pointer to its initial state
224− and then calls sqlite3_column_type
227−int sqlite3_get_data_type(void* p, int nRow, int nCol){
229− DBinfo* dbi =(DBinfo*) p;
230− int rc, type, row_counter;
231− const char* char_int;
233− rc = sqlite3_reset(dbi->ppStmt);
234− rc = sqlite3_step(dbi->ppStmt);
237− while (rc == SQLITE_ROW && row_counter < nRow) {
239− rc = sqlite3_step(dbi->ppStmt);
242− type =sqlite3_column_type(dbi->ppStmt, nCol);
247− Obtains the integer value in a given column
250−int sqlite3_get_val_int(void* p, int nCol){
252− DBinfo* dbi =(DBinfo*) p;
254− val =sqlite3_column_int(dbi->ppStmt, nCol);
259− Obtains the text value
260− Need to allocate memory to store the string
261− Use GC_malloc since Boehm garbage collector
262− frees the resources .
264−const unsigned char* sqlite3_get_val_text(void* p,int nCol){
267− DBinfo* dbi =(DBinfo*) p;
268− int rc,i, val, counter;
269− const unsigned char* text_val;
270− array =(unsigned char *) malloc(1000*sizeof(char));
271− text_val =sqlite3_column_text(dbi->ppStmt, nCol);
272− memcpy(array, text_val, strlen(text_val));
276−float sqlite3_get_float(void* p, int nCol){
278− DBinfo* dbi =(DBinfo*) p;
281− double_val =sqlite3_column_double(dbi->ppStmt, nCol);
282− float float_val =(float)double_val;
287− frees the pointer returned by get_table.
290−void sqlite3_free_table_idr(void* db){
291− Table* tbl =(Table*) db;
292− sqlite3_free_table(tbl->table_data);
295−int sqlite3_step_idr(void* db){
297− DBinfo* dbi =(DBinfo*) db;
298− int rc =sqlite3_step(dbi->ppStmt);
302− Binds integer. This returns a pointer
303− because of the implementation of BindMulti
304− which binds multiple values
306−void* sqlite3_bind_int_idr(void* p,int index, int val){
308− DBinfo* dbi =(DBinfo*) p;
311− rc =sqlite3_bind_int(dbi->ppStmt,index,val);
312− if(rc != SQLITE_OK){
319−void* sqlite3_bind_float_idr(void* p,int index, float val){
321− DBinfo* dbi =(DBinfo*) p;
323− double res =(float)val;
325− rc =sqlite3_bind_double(dbi->ppStmt,index,res);
327− if(rc != SQLITE_OK){
333−void* sqlite3_bind_null_idr(void* p,int index){
335− DBinfo* dbi =(DBinfo*) p;
337− rc =sqlite3_bind_null(dbi->ppStmt,index);
338− if(rc != SQLITE_OK){
345−void* sqlite3_bind_text_idr(void* p,const char* text, int index,int length){
347− DBinfo* dbi =(DBinfo*) p;
349− rc =sqlite3_bind_text(dbi->ppStmt,index,text,length,SQLITE_STATIC);
350− if(rc != SQLITE_OK){
357− Used for testing column count function.
358− This function prepares query and by passing
359− select all, gets the count for column number
360− Could be used for testing. Not recommended to
361− be used with prepare and exec
364−int sqlite3_column_count_idr(void* db, const char* tbl_name){
365− DBinfo* dbi =(DBinfo*) db;
370− strcpy(sql_query_buffer, "select * from ");
371− strcat(sql_query_buffer, tbl_name);
373− rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
374− if(rc != SQLITE_OK){
375− fprintf(stderr, "SQL Prepare error");
378− printf("Prepare successful %d\n", rc);
380− rc =sqlite3_column_count(stmt);
382− fprintf(stderr, "SQL column count error\n");
385− sqlite3_finalize(stmt);
387− // rc = actual column count
391−int sqlite3_data_count_idr(void* db){
393− DBinfo* dbi =(DBinfo*) db;
394− int rc = sqlite3_data_count(dbi->ppStmt);
399− Must be called after prepare to clean up
402−int sqlite3_finalize_idr(void* db){
404− DBinfo* dbi=(DBinfo*) db;
405− int rc =sqlite3_finalize(dbi->ppStmt);
409−int sqlite3_complete_idr(const char *sql){
411− int rc = sqlite3_complete(sql);
416− Resets a prepared statement pointer
417− to its initial state
419−int sqlite3_reset_idr(void* db){
421− DBinfo* dbi=(DBinfo*) db;
422− int rc = sqlite3_reset(dbi-> ppStmt);
427− The following routines may be used to
428− obtain column related information.
430−const char *sqlite3_column_name_idr(void* db, int N){
432− DBinfo* dbi=(DBinfo*) db;
433− const char *name = sqlite3_column_name(dbi->ppStmt, N);
438−const char *sqlite3_column_decltype_idr(void* db,int n){
439− DBinfo* dbi=(DBinfo*) db;
440− const char *dectype = sqlite3_column_decltype(dbi->ppStmt, n);
445−int sqlite3_column_bytes_idr(void* db, int n){
447− DBinfo* dbi=(DBinfo*) db;
448− int res = sqlite3_column_bytes(dbi->ppStmt, n);
453−const void *sqlite3_column_blob_idr(void* db, int iCol){
454− DBinfo* dbi=(DBinfo*) db;
455− const void* data =sqlite3_column_blob(dbi-> ppStmt, iCol);
459−const unsigned char *sqlite3_column_text_idr(void* db, int iCol){
460− DBinfo* dbi=(DBinfo*) db;
461− const unsigned char* col_text =sqlite3_column_text(dbi->ppStmt, iCol);
466−int sqlite3_column_int_idr(void* db, int iCol){
467− DBinfo* dbi=(DBinfo*) db;
468− int res =sqlite3_column_int(dbi-> ppStmt, iCol);
473− Some back up functions
476−void* sqlite3_backup_init_idr(void* pDest,
477− const char *zDestName,
479− const char *zSourceName
482− DBinfo* dbi=(DBinfo*) pDest;
483− DBbackup* dbi2=(DBbackup*) pSource;
485− void* res = sqlite3_backup_init(dbi->db_ptr,zDestName,
486− dbi2->source_ptr,zSourceName);
489− printf("Error number in initializing backup : %d\n", sqlite3_errcode(dbi->db_ptr));
498−int sqlite3_backup_step_idr(void *backup, int nPage){
500− DBbackup* dbi=(DBbackup*) backup;
501− int res = sqlite3_backup_step(dbi->backup, nPage);
506−int sqlite3_backup_finish_idr(void *backup){
508− DBbackup* dbi=(DBbackup*) backup;
509− int res = sqlite3_backup_finish(dbi->backup);
515−int sqlite3_backup_remaining_idr(void *backup){
517− DBbackup* dbi=(DBbackup*) backup;
518− int res = sqlite3_backup_remaining(dbi->backup);
523−int sqlite3_backup_pagecount_idr(void *backup){
525− DBbackup* dbi=(DBbackup*) backup;
526− int res =sqlite3_backup_pagecount(dbi-> backup);
531− Get the length of string
532− Need this in Idris since length will not
535−int strLength(const char * str){
537− int length = strlen(str);
contribs/lib/SQLite3/sqlite3api.hdeleted−130
@@ -1,130 +0,0 @@
5− * Created by Melissa Farinaz MOZIFIAN on 22/06/2012.
6− * Copyright 2012. All rights reserved.
17− sqlite3 *db_ptr; // database pointer
18− sqlite3_stmt *ppStmt; // statement pointer
19− char buffer[1000]; // bufer to store errors returned by certain functions
20− const char *Ptr_tail;
21− sqlite3_value *value;
22− int row_count; // row number store by exec function
27−// struct used for backup functions
30− sqlite3_backup *backup;
33−// Table struct used by get_table function
34−// stores row and column
35−// returned by get_table
46−void* sqlite3_open_idr(const char *filename);
50−int sqlite3_close_idr(void* db);
52−int sqlite3_exec_idr(void*, const char *sql);
54−char* sqlite3_get_error(void* db);
56−const unsigned char* sqlite3_get_val_text(void* p,int nCol);
58−void* sqlite3_get_table_idr(void* db, const char *sql);
60−void sqlite3_free_table_idr(void* db);
62−int sqlite3_get_num_col(void* p);
64−int sqlite3_get_num_row(void* p);
66−int sqlite3_get_num_row_v2(void* p);
68−int sqlite3_get_num_col_v2(void* p);
70−int sqlite3_get_data_type(void* p, int nRow, int nCol);
72−int sqlite3_get_val_int(void* p,int nCo);
74−float sqlite3_get_float(void* p, int nCol);
76−void* sqlite3_prepare_idr(
77− void *db, /* Database handle */
78− const char *zSql /* SQL statement, UTF-8 encoded */
81−int sqlite3_step_idr(void* stmt);
83−void* sqlite3_bind_float_idr(void* p,int index, float val);
85−void* sqlite3_bind_int_idr(void* p,int index , int val);
87−void* sqlite3_bind_null_idr(void* p,int index);
89−void* sqlite3_bind_text_idr(void* p,const char* text, int index,int length);
91−int sqlite3_column_count_idr(void* stmt, const char* tbl_name);
93−int sqlite3_data_count_idr(void* stmt);
95−int sqlite3_reset_idr(void* stmt);
97−int sqlite3_finalize_idr(void* stmt);
99−int sqlite3_complete_idr(const char *sql);
101−const char *sqlite3_column_decltype_idr(void* stmt,int n);
103−const char *sqlite3_column_name_idr(void* stmt, int N);
105−int sqlite3_column_bytes_idr(void* stmt, int n);
107−int sqlite3_column_bytes_idr(void* stmt, int n);
109−const void *sqlite3_column_blob_idr(void* stmt, int iCol);
111−const unsigned char *sqlite3_column_text_idr(void* stmt, int iCol);
113−int sqlite3_column_int_idr(void* stmt, int iCol);
116−void* sqlite3_backup_init_idr(void* pDestm,
117− const char *zDestName,
119− const char *zSourceName
122−int sqlite3_backup_finish_idr(void *backup);
124−int sqlite3_backup_step_idr(void *backup, int nPage);
126−int sqlite3_backup_remaining_idr(void *backup);
128−int sqlite3_backup_pagecount_idr(void *backup);
130−int strLength(const char * str);
contribs/lib/SQLite3/students.dbdeleted
Binary file not shown.
contribs/lib/SQLite3/testunit.idrdeleted−140
@@ -1,140 +0,0 @@
6−testexpr = do db <- open_db "somedb.db"
7− let sql = (evalSQL [] ((SELECT ALL)(TBL ["tbl1"]) (OR (AND (MkCond (Equals (VCol "data")(VStr "data0"))) (MkCond (Equals (VCol "num")(VInt 1))) ) (MkCond (Equals (VCol "num")(VInt 2))))))
8− let x = (fst sql) -- get the string
9− let list = (snd sql) -- list of vals
10− liftIO(print x) -- use liftIO to turn this into DB type
11− stmt <- (prepare_db db x) -- prepare the statement
12− bindMulti stmt list -- bind the values in the list
13− exec_db_v2 stmt -- execute the prepared query
14− res <- toList_v1 db -- toList_v1 to get the result
15− liftIO(print res) -- print the result
16− finalize_db stmt -- Statment pointer must be finalized in the end
17− close_db db -- close the datbase
21−testupdate = do db <- open_db "somedb.db"
22− let sql = (evalSQL [] (UPDATE (TBL ["tbl1"]) (WHERE (SET (MkCond (Equals(VCol "data") (VStr "data600"))) ) (MkCond (Equals (VCol "num") (VInt 2))) ) ))
26− stmt <- (prepare_db db x)
34−testInsert = do db <- open_db "somedb.db"
35− let sql = (evalSQL [] (INSERT (TBL ["tbl1"]) [(VInt 3),(VStr "ham")]))
39− stmt <- (prepare_db db x)
47−testNull = do db <- open_db "somedb.db"
48− let sql = (evalSQL [] ((SELECT ALL)(TBL ["tbl1"]) (MkCond (MkNULL (VCol "data")))))
52− stmt <- (prepare_db db x)
62−testInsertWithCond : DB()
63−testInsertWithCond = do db <- open_db "somedb.db"
64− let sql = (evalSQL [] (INSERTC (TBL ["tbl1"]) [(VCol "data"),(VCol "num")] [(VInt 30),(VStr "inserthere")]))
68− stmt <- (prepare_db db x)
75−-- Nested queries need to have the same column as the outer queries.
77−testNestedSel1 = do db <- open_db "somedb.db"
78− let sql = (evalSQL [] (SELECT (Cols ["data"]) (SELECT (Cols["num","data"]) (TBL ["tbl1"]) (MkCond (MkGT (VCol "num")(VInt 2))))Empty))
82− stmt <- (prepare_db db x)
91−-- Testing Create Table
92−testCreateTable : DB ()
93−testCreateTable = do db <- open_db "somedb.db"
94− let sql = (evalSQL [] (CREATE (TBL ["mynewtbl"]) [ ((VCol "col"),(CInt "int"),(None)) ] ) )
98− stmt <- (prepare_db db x)
105−-- This may be a bit slow
106−testMultiTable : DB ()
107−testMultiTable = do db <- open_db "somedb.db"
108− let sql = (evalSQL [] ((SELECT ALL )(TBL ["mytable","tbl1"]) (Empty) ) )
110− let list = (snd sql)
112− stmt <- (prepare_db db x)
122−testSelAll = do db <- open_db "somedb.db"
123− let sql = (evalSQL [] ((SELECT ALL )(TBL ["tbl1"]) (Empty) ) )
125− let list = (snd sql)
127− stmt <- (prepare_db db x)
138−main = do x <- runDB (testMultiTable) -- runDB : DB a -> IO a
139− --y <- runDB (testNestedSel1)
contribs/lib/SimpleParser/SimpleParser.idrdeleted−190
@@ -1,190 +0,0 @@
2− Simple monadic parser module, based heavily on that by
10−import Prelude.Applicative
17−--------------------------------------------------------------------------------
18−-- The monad of parsers
19−--------------------------------------------------------------------------------
21−data Parser a = P (String -> Either String (a, String))
23−parse : Parser a -> String -> Either String (a, String)
24−parse (P p) inp = p inp
26−instance Functor Parser where
27− map f p = P (\inp => case parse p inp of
29− Right (v, rest) => Right ((f v), rest))
31−instance Applicative Parser where
32− pure v = P (\inp => Right (v, inp))
33− a <$> b = P (\inp => do (f, rest) <- parse a inp
34− (x, rest') <- parse b rest
37−instance Monad Parser where
38− p >>= f = P (\inp => case parse p inp of
40− Right (v,rest) => parse (f v) rest)
42−instance Alternative Parser where
43− empty = P (const (Left "empty"))
44− p <|> q = P (\inp => case parse p inp of
45− Left msg => parse q inp
46− Right (v,out) => Right (v,out))
49−--------------------------------------------------------------------------------
51−--------------------------------------------------------------------------------
53−failure : String -> Parser a
54−failure msg = P (\inp => Left msg)
57−item = P (\inp => case choose (inp == "") of
58− Left _ => Left "Error! Parsing empty list."
59− Right p => Right (strHead' inp p, strTail' inp p))
62−--------------------------------------------------------------------------------
64−--------------------------------------------------------------------------------
66−sat : (Char -> Bool) -> Parser Char
71−oneof : List Char -> Parser Char
72−oneof xs = sat (\x => elem x xs)
86−alphanum : Parser Char
87−alphanum = sat isAlphaNum
89−char : Char -> Parser Char
92−string : String -> Parser String
93−string s = map pack (traverse char (unpack s))
96− many1 : Parser a -> Parser (List a)
97− many1 p = [| p :: many p |]
99− many : Parser a -> Parser (List a)
100− many p = lazy (many1 p) <|> pure []
103−bool = parseTrue <|> parseFalse
104− where parseTrue : Parser Bool
105− parseTrue = do oneof ['T', 't']
108− parseFalse = do oneof ['F', 'f']
112−ident : Parser String
114− where xs : Parser (List Char)
115− xs = [| letter :: many1 alphanum |]
118−nat = do xs <- many digit
119− pure (cast (cast xs))
123− where neg : Parser Int
129−space = do many (sat isSpace)
133−--------------------------------------------------------------------------------
135−--------------------------------------------------------------------------------
137−token : Parser a -> Parser a
138−token p = space $> p <$ space
140−identifier : Parser String
141−identifier = token ident
149−symbol : String -> Parser String
150−symbol xs = token (string xs)
152−strToken : Parser String
153−strToken = map pack (token (many1 alphanum))
155−--------------------------------------------------------------------------------
157−--------------------------------------------------------------------------------
159−optional : Parser a -> Parser (Maybe a)
160−optional p = map Just p <|> pure Nothing
162−sepBy1 : Parser a -> Parser b -> Parser (List a)
163−sepBy1 p s = [| p :: many (s $> p) |]
165−sepBy : Parser a -> Parser b -> Parser (List a)
166−sepBy p s = sepBy1 p s <|> pure Nil
168−manyTil : Parser a -> Parser b -> Parser (List a)
169−manyTil p e = (e $> pure Nil) <|> lazy [| p :: manyTil p e |] <|> pure Nil
171−--------------------------------------------------------------------------------
173−--------------------------------------------------------------------------------
180− map (t+) (symbol "+" $> expr) <|> pure t
182−factor = (symbol "(" $> expr <$ symbol ")") <|> natural
184−term = do f <- factor
185− map (f*) (symbol "*" $> term) <|> pure f
187−eval : String -> Maybe Int
188−eval xs = case (parse expr xs) of
189− Right (n,rest) => if rest == "" then Just n else Nothing
contribs/lib/SimpleParser/simpleparser.ipkgdeleted−4
contribs/tool-support/completion/idris.bashdeleted−31
@@ -1,31 +0,0 @@
2− local cur prev words opts LIBRARIES TARGETS
3− _init_completion || return
5− opts=$(_parse_help "$1")
7− TARGETS="C Java bytecode javascript node"
17− COMPREPLY=( $(compgen -W "${LIBRARIES}" -- ${cur}))
20− COMPREPLY=( $(compgen -W "${TARGETS}" -- ${cur}))
24− if [[ $cur == -* ]]; then
25− COMPREPLY=($(compgen -W "${opts}" -- ${cur}))
31−complete -o default -F _idris idris
contribs/tool-support/sublime-text/Idris/Idris.JSON-tmLanguagedeleted−70
@@ -1,70 +0,0 @@
2− "scopeName": "source.idris",
5− { "name": "keyword.control.idris",
6− "match": "\\b(if|then|else|do|let|in|data|codata|record|dsl|import)\\b"
9− { "name": "keyword.control.idris",
10− "match": "\\b(impossible|case|of|total|partial|mutual|infix|infixl|infixr)\\b"
13− { "name": "keyword.control.idris",
14− "match": "\\b(where|with|syntax|proof|postulate|using|namespace|class|instance)\\b"
17− { "name": "keyword.control.idris",
18− "match": "\\b(public|private|abstract|implicit)\\b"
21− { "name": "keyword.other.idris",
22− "match": "\\b(Type|Int|Integer|Float|Char|String|Ptr|Bits8|Bits16|Bits32|Bits64)\\b"
24− { "name": "constant.numeric.idris",
25− "match": "\\b(S|O)\\b"
27− { "match": "\\b([0-9]+|0([xX][0-9a-fA-F]+|[oO][0-7]+))\\b",
28− "name": "constant.numeric.idris",
29− "comment": "integers"
32− "match": "\\b([0-9]+\\.[0-9]+([eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)\\b",
33− "name": "constant.numeric.float.idris",
37− "name": "comment.line.idris",
38− "match": "(--).*$\n?",
39− "comment": "Line comment"
41− { "name": "comment.block.idris",
44− "comment": "Block comment"
47− "name": "string.quoted.idris",
50− "0": { "name": "punctuation.definition.string.begin.idris"}
54− "0": { "name": "punctuation.definition.string.end.idris"}
57− { "name": "constant.character.escape.idris",
69− "uuid": "4dd16092-ffa5-4ba4-8075-e5da9f368a72"
contribs/tool-support/sublime-text/Idris/Idris.tmLanguagedeleted−126
@@ -1,126 +0,0 @@
1−<?xml version="1.0" encoding="UTF-8"?>
2−<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
10− <string>Idris</string>
15− <string>\b(if|then|else|do|let|in|data|codata|record|dsl|import)\b</string>
17− <string>keyword.control.idris</string>
21− <string>\b(impossible|case|of|total|partial|mutual|infix|infixl|infixr)\b</string>
23− <string>keyword.control.idris</string>
27− <string>\b(where|with|syntax|proof|postulate|using|namespace|class|instance)\b</string>
29− <string>keyword.control.idris</string>
33− <string>\b(public|private|abstract|implicit)\b</string>
35− <string>keyword.control.idris</string>
39− <string>\b(Type|Int|Integer|Float|Char|String|Ptr|Bits8|Bits16|Bits32|Bits64)\b</string>
41− <string>keyword.other.idris</string>
45− <string>\b(S|O)\b</string>
47− <string>constant.numeric.idris</string>
51− <string>integers</string>
53− <string>\b([0-9]+|0([xX][0-9a-fA-F]+|[oO][0-7]+))\b</string>
55− <string>constant.numeric.idris</string>
59− <string>floats</string>
61− <string>\b([0-9]+\.[0-9]+([eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)\b</string>
63− <string>constant.numeric.float.idris</string>
67− <string>Line comment</string>
72− <string>comment.line.idris</string>
78− <string>Block comment</string>
82− <string>comment.block.idris</string>
87− <key>beginCaptures</key>
92− <string>punctuation.definition.string.begin.idris</string>
97− <key>endCaptures</key>
102− <string>punctuation.definition.string.end.idris</string>
106− <string>string.quoted.idris</string>
111− <string>\\"</string>
113− <string>constant.character.escape.idris</string>
118− <key>repository</key>
121− <key>scopeName</key>
122− <string>source.idris</string>
124− <string>4dd16092-ffa5-4ba4-8075-e5da9f368a72</string>
contribs/tool-support/sublime-text/Idris/idris.sublime-builddeleted−5
@@ -1,5 +0,0 @@
2− "cmd": ["idris", "$file"],
3− "file_regex": "^(...*?):([0-9]*):?([0-9]*)",
4− "selector": "source.idris"
contribs/tool-support/sublime-text/README.mddeleted−11
@@ -1,11 +0,0 @@
1−#### Idris support for Sublime Text 2
3−To install, copy the Idris directory to Sublime Text's Packages directory.
5−To build a new Idris.tmLanguage file from the Idris.JSON-tmLanguage file, Sublime Text needs to have the AAAPackageDev package installed.
7−Syntax Definitions tutorial: https://sublime-text-unofficial-documentation.readthedocs.org/en/latest/extensibility/syntaxdefs.html
9−Syntax Definitions reference: https://sublime-text-unofficial-documentation.readthedocs.org/en/latest/reference/syntaxdefs.html
11−Most used scopes: http://manual.macromates.com/en/language_grammars#naming_conventions
@@ -1,2 +1 @@
1−CABALFLAGS += -f LLVM -f FFI -f curses
1+CABALFLAGS += -f GMP -f FFI --disable-documentation --disable-profiling --disable-library-profiling
docs/.gitignorenew file+3
@@ -0,0 +1,10 @@
1+#+TITLE: Licensing Information
3+The documentation for Idris has been published under the Creative
4+Commons CC0 License. As such to the extent possible under law, /The
5+Idris Community/ has waived all copyright and related or neighboring
6+rights to Documentation for Idris.
8+More information concerning the CC0 can be found online at:
10+ https://creativecommons.org/publicdomain/zero/1.0/
docs/Makefilenew file+183
@@ -0,0 +1,183 @@
1+# Makefile for Sphinx documentation
4+# You can set these variables from the command line.
6+SPHINXBUILD = sphinx-build
10+# User-friendly check for sphinx-build
11+ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
12+$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from https://www.sphinx-doc.org/)
16+PAPEROPT_a4 = -D latex_paper_size=a4
17+PAPEROPT_letter = -D latex_paper_size=letter
18+ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
19+# the i18n builder cannot share the environment and doctrees with the others
20+I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
22+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest coverage gettext
25+ @echo "Please use \`make <target>' where <target> is one of"
26+ @echo " html to make standalone HTML files"
27+ @echo " dirhtml to make HTML files named index.html in directories"
28+ @echo " singlehtml to make a single large HTML file"
29+ @echo " pickle to make pickle files"
30+ @echo " json to make JSON files"
31+ @echo " htmlhelp to make HTML files and a HTML help project"
32+ @echo " qthelp to make HTML files and a qthelp project"
33+ @echo " devhelp to make HTML files and a Devhelp project"
34+ @echo " epub to make an epub"
35+ @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
36+ @echo " latexpdf to make LaTeX files and run them through pdflatex"
37+ @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
38+ @echo " text to make text files"
39+ @echo " man to make manual pages"
40+ @echo " texinfo to make Texinfo files"
41+ @echo " info to make Texinfo files and run them through makeinfo"
42+ @echo " gettext to make PO message catalogs"
43+ @echo " changes to make an overview of all changed/added/deprecated items"
44+ @echo " xml to make Docutils-native XML files"
45+ @echo " pseudoxml to make pseudoxml-XML files for display purposes"
46+ @echo " linkcheck to check all external links for integrity"
47+ @echo " doctest to run all doctests embedded in the documentation (if enabled)"
48+ @echo " coverage to run coverage check of the documentation (if enabled)"
54+ $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
56+ @echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
59+ $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
61+ @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
64+ $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
66+ @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
69+ $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
71+ @echo "Build finished; now you can process the pickle files."
74+ $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
76+ @echo "Build finished; now you can process the JSON files."
79+ $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
81+ @echo "Build finished; now you can run HTML Help Workshop with the" \
82+ ".hhp project file in $(BUILDDIR)/htmlhelp."
85+ $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
87+ @echo "Build finished; now you can run "qcollectiongenerator" with the" \
88+ ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
89+ @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/IdrisManual.qhcp"
90+ @echo "To view the help file:"
91+ @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/IdrisManual.qhc"
94+ $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
96+ @echo "Build finished."
97+ @echo "To view the help file:"
98+ @echo "# mkdir -p $$HOME/.local/share/devhelp/IdrisManual"
99+ @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/IdrisManual"
103+ $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
105+ @echo "Build finished. The epub file is in $(BUILDDIR)/epub."
108+ $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
110+ @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
111+ @echo "Run \`make' in that directory to run these through (pdf)latex" \
112+ "(use \`make latexpdf' here to do that automatically)."
115+ $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
116+ @echo "Running LaTeX files through pdflatex..."
117+ $(MAKE) -C $(BUILDDIR)/latex all-pdf
118+ @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
121+ $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
122+ @echo "Running LaTeX files through platex and dvipdfmx..."
123+ $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
124+ @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
127+ $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
129+ @echo "Build finished. The text files are in $(BUILDDIR)/text."
132+ $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
134+ @echo "Build finished. The manual pages are in $(BUILDDIR)/man."
137+ $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
139+ @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
140+ @echo "Run \`make' in that directory to run these through makeinfo" \
141+ "(use \`make info' here to do that automatically)."
144+ $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
145+ @echo "Running Texinfo files through makeinfo..."
146+ make -C $(BUILDDIR)/texinfo info
147+ @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
150+ $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
152+ @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
155+ $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
157+ @echo "The overview file is in $(BUILDDIR)/changes."
160+ $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
162+ @echo "Link check complete; look for any errors in the above output " \
163+ "or in $(BUILDDIR)/linkcheck/output.txt."
166+ $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
167+ @echo "Testing of doctests in the sources finished, look at the " \
168+ "results in $(BUILDDIR)/doctest/output.txt."
171+ $(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
172+ @echo "Testing of coverage in the sources finished, look at the " \
173+ "results in $(BUILDDIR)/coverage/python.txt."
176+ $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
178+ @echo "Build finished. The XML files are in $(BUILDDIR)/xml."
181+ $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
183+ @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
docs/README.mdnew file+51
@@ -0,0 +1,51 @@
1+# Documentation for the Idris Language.
4+This manual has been prepared using ReStructured Text and the [Sphinx Documentation Generator](https://www.sphinx-doc.org) for future inclusion on [Read The Docs](https://www.readthedocs.org).
8+To build the manual the following dependencies must be met. We assume that you have standard build automation tools already install i.e. `make`.
12+Python should be installed by default on most systems.
13+Sphinx can be installed either through your hosts package manager or using pip/easy_install.
15+*Note* [ReadTheDocs](https://www.readthedocs.org) works with Sphinx
16+ `v1.2.2`. If you install a more recent version of sphinx then
17+ 'incorrectly' marked up documentation may get passed the build system
18+ of readthedocs and be ignored. In the past we had several code-blocks
19+ disappear because of that.
21+The ReadTheDocs theme can be installed using pip as follows:
24+pip install sphinx_rtd_theme
29+LaTeX can be install either using your systems package manager or direct from TeXLive.
41+The documentation for Idris has been published under the Creative
42+Commons CC0 License. As such to the extent possible under law, /The
43+Idris Community/ has waived all copyright and related or neighboring
44+rights to Documentation for Idris.
46+More information concerning the CC0 can be found online at:
48+ https://creativecommons.org/publicdomain/zero/1.0/
51+When contributing material to the manual please bear in mind that the work will be licensed as above.
docs/_static/theme_overrides.cssnew file+13
@@ -0,0 +1,13 @@
1+/* override table width restrictions */
2+@media screen and (min-width: 767px) {
4+ .wy-table-responsive table td {
5+ /* !important prevents the common CSS stylesheets from overriding
6+ this as on RTD they are loaded after this stylesheet */
7+ white-space: normal !important;
10+ .wy-table-responsive {
11+ overflow: visible !important;
@@ -0,0 +1,437 @@
1+# -*- coding: utf-8 -*-
3+# Idris Manual documentation build configuration file, created by
4+# sphinx-quickstart on Sat Feb 28 20:41:47 2015.
6+# This file is execfile()d with the current directory set to its
9+# Note that not all possible configuration values are present in this
12+# All configuration values have a default; values that are commented out
13+# serve to show the default.
18+# True if the readthedocs theme is locally installed
19+on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
21+# If extensions (or modules to document with autodoc) are in another directory,
22+# add these directories to sys.path here. If the directory is relative to the
23+# documentation root, use os.path.abspath to make it absolute, like shown here.
24+#sys.path.insert(0, os.path.abspath('.'))
26+# -- General configuration ------------------------------------------------
28+# If your documentation needs a minimal Sphinx version, state it here.
31+# Add any Sphinx extension module names here, as strings. They can be
32+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
36+# 'sphinx.ext.pngmath', # imgmath is not supported on readthedocs.
37+ 'sphinx.ext.ifconfig',
40+# Add any paths that contain templates here, relative to this directory.
41+templates_path = ['_templates']
43+# The suffix of source filenames.
44+source_suffix = '.rst'
46+# The encoding of source files.
47+#source_encoding = 'utf-8-sig'
49+# The master toctree document.
52+# General information about the project.
54+copyright = u'2017-2020, The Idris Community'
55+author = u'The Idris Community'
57+# The version info for the project you're documenting, acts as replacement for
58+# |version| and |release|, also used in various other places throughout the
61+# The short X.Y version.
63+# The full version, including alpha/beta/rc tags.
66+# The language for content autogenerated by Sphinx. Refer to documentation
67+# for a list of supported languages.
69+# This is also used if you do content translation via gettext catalogs.
70+# Usually you set "language" from the command line for these cases.
73+# There are two options for replacing |today|: either, you set today to some
74+# non-false value, then it is used:
76+# Else, today_fmt is used as the format for a strftime call.
77+#today_fmt = '%B %d, %Y'
79+# List of patterns, relative to source directory, that match files and
80+# directories to ignore when looking for source files.
81+exclude_patterns = ['_build']
83+# The reST default role (used for this markup: `text`) to use for all
87+# If true, '()' will be appended to :func: etc. cross-reference text.
88+#add_function_parentheses = True
90+# If true, the current module name will be prepended to all description
91+# unit titles (such as .. function::).
92+#add_module_names = True
94+# If true, sectionauthor and moduleauthor directives will be shown in the
95+# output. They are ignored by default.
98+# The name of the Pygments (syntax highlighting) style to use.
99+pygments_style = 'sphinx'
101+# A list of ignored prefixes for module index sorting.
102+#modindex_common_prefix = []
104+# If true, keep warnings as "system message" paragraphs in the built documents.
105+#keep_warnings = False
107+# If true, `todo` and `todoList` produce output, else they produce nothing.
108+todo_include_todos = True
111+# -- Options for HTML output ----------------------------------------------
113+# The theme to use for HTML and HTML Help pages. See the documentation for
114+# a list of builtin themes.
115+html_theme = "default"
117+if not on_rtd: # only import and set the theme if we're building docs locally
119+ import sphinx_rtd_theme
120+ html_theme = 'sphinx_rtd_theme'
121+ html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
123+ html_theme = "default"
125+# Theme options are theme-specific and customize the look and feel of a theme
126+# further. For a list of options available for each theme, see the
128+#html_theme_options = {}
130+# Add any paths that contain custom themes here, relative to this directory.
131+#html_theme_path = []
133+# The name for this set of Sphinx documents. If None, it defaults to
134+# "<project> v<release> documentation".
137+# A shorter title for the navigation bar. Default is the same as html_title.
138+#html_short_title = None
140+# The name of an image file (relative to this directory) to place at the top
144+# The name of an image file (within the static path) to use as favicon of the
145+# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
149+# Add any paths that contain custom static files (such as style sheets) here,
150+# relative to this directory. They are copied after the builtin static files,
151+# so a file named "default.css" will overwrite the builtin "default.css".
152+html_static_path = ['_static']
156+ '_static/theme_overrides.css', # override wide tables in RTD theme
160+# Add any extra paths that contain custom files (such as robots.txt or
161+# .htaccess) here, relative to this directory. These files are copied
162+# directly to the root of the documentation.
163+#html_extra_path = []
165+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
166+# using the given strftime format.
167+#html_last_updated_fmt = '%b %d, %Y'
169+# If true, SmartyPants will be used to convert quotes and dashes to
170+# typographically correct entities.
171+#html_use_smartypants = True
173+# Custom sidebar templates, maps document names to template names.
176+# Additional templates that should be rendered to pages, maps page names to
178+#html_additional_pages = {}
180+# If false, no module index is generated.
181+#html_domain_indices = True
183+# If false, no index is generated.
184+#html_use_index = True
186+# If true, the index is split into individual pages for each letter.
187+#html_split_index = False
189+# If true, links to the reST sources are added to the pages.
190+#html_show_sourcelink = True
192+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
193+#html_show_sphinx = True
195+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
196+#html_show_copyright = True
198+# If true, an OpenSearch description file will be output, and all pages will
199+# contain a <link> tag referring to it. The value of this option must be the
200+# base URL from which the finished HTML is served.
201+#html_use_opensearch = ''
203+# This is the file name suffix for HTML files (e.g. ".xhtml").
204+#html_file_suffix = None
206+# Language to be used for generating the HTML full-text search index.
207+# Sphinx supports the following languages:
208+# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
209+# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
210+#html_search_language = 'en'
212+# A dictionary with options for the search language support, empty by default.
213+# Now only 'ja' uses this config value
214+#html_search_options = {'type': 'default'}
216+# The name of a javascript file (relative to the configuration directory) that
217+# implements a search results scorer. If empty, the default will be used.
218+#html_search_scorer = 'scorer.js'
220+# Output file base name for HTML help builder.
221+htmlhelp_basename = 'IdrisManualdoc'
223+# -- Options for LaTeX output ---------------------------------------------
225+latex_title_page = r'''
229+ \includegraphics[width=0.25\textwidth]{idris-512x512.png}\par
231+ {\huge\sffamily\bfseries \makeatletter\@title\makeatother\par}
233+ {\Large Version \version\par}
240+# The paper size ('letterpaper' or 'a4paper').
241+'papersize': 'a4paper',
246+'releasename': 'Version',
248+# The font size ('10pt', '11pt' or '12pt').
251+# Additional stuff for the LaTeX preamble.
254+\usepackage{textalpha}
255+\usepackage[T1]{fontenc}
256+\usepackage[utf8x]{inputenc}
257+\usepackage{titlesec}
259+\usepackage{fancyhdr}
260+\fancypagestyle{plain}{%
261+ \renewcommand{\headrulewidth}{0pt}%
263+ \fancyfoot[C]{\textsf{\thepage}}
267+\fancyhead[LE,RO]{\textsf{\bfseries{v\version}}}
268+\fancyhead[LO,RE]{\textsf{\bfseries\leftmark}}
269+%\fancyhead[LO]{\textsf{\bfseries{\leftmark}}}
270+%\fancyhead[RO]{\textsf{\bfseries{v\version}}}
271+%\fancyhead[RE]{\textsf{\bfseries{\leftmark}}}
272+%\fancyhead[LE]{\textsf{\bfseries{v\version}}}
273+\fancyfoot[C]{\textsf{\thepage}}
274+\renewcommand{\footrulewidth}{0pt}
275+\renewcommand{\headrulewidth}{0pt}
277+\usepackage[font={small,it}]{caption}
278+\titleformat{\section}
279+ {\normalfont\sffamily\Large\bfseries\color{black}}
280+ {\thesection}{1em}{}
281+\titleformat{\subsection}
282+ {\sffamily\large\bfseries\color{black}}
283+ {\thesubsection}{1em}{}
284+\titleformat{\subsubsection}
285+ {\sffamily\normalsize\bfseries\color{black}}
286+ {\thesubsubsection}{1em}{}
287+\titleformat{\paragraph}{\normalfont\normalsize\slshape}{\theparagraph}{1em}{}
288+\setlength{\parskip}{1em}
290+\hypersetup{colorlinks = false}
291+\definecolor{VerbatimBorderColor}{rgb}{1,1,1}
294+'maketitle': latex_title_page,
295+'tableofcontents': "\\tableofcontents"
296+# Latex figure (float) alignment
297+#'figure_align': 'htbp',
300+# Grouping the document tree into LaTeX files. List of tuples
301+# (source start file, target name, title,
302+# author, documentclass [howto, manual, or own class]).
304+ # (master_doc, 'idris.tex', u'Documentation for the Idris Language', u'The Idris Community', 'report')
305+ ('tutorial/index', 'idris-tutorial.tex', u'The Idris Tutorial', u'The Idris Community', 'howto'),
309+latex_show_pagerefs = True
310+latex_show_url = 'footnote'
312+# The name of an image file (relative to this directory) to place at the top of
314+latex_logo = '../icons/idris-512x512.png'
316+# For "manual" documents, if this is true, then toplevel headings are parts,
318+#latex_use_parts = True
320+# If true, show page references after internal links.
321+#latex_show_pagerefs = False
323+# If true, show URL addresses after external links.
324+#latex_show_urls = False
326+# Documents to append as an appendix to all manuals.
327+#latex_appendices = []
329+# If false, no module index is generated.
330+#latex_domain_indices = True
333+# -- Options for manual page output ---------------------------------------
335+# One entry per manual page. List of tuples
336+# (source start file, name, description, authors, manual section).
338+ (master_doc, 'idrismanual', u'Idris Manual Documentation',
342+# If true, show URL addresses after external links.
343+#man_show_urls = False
346+# -- Options for Texinfo output -------------------------------------------
348+# Grouping the document tree into Texinfo files. List of tuples
349+# (source start file, target name, title, author,
350+# dir menu entry, description, category)
351+texinfo_documents = [
352+ (master_doc, 'IdrisManual', u'Idris Manual Documentation',
353+ author, 'IdrisManual', 'One line description of project.',
357+# Documents to append as an appendix to all manuals.
358+#texinfo_appendices = []
360+# If false, no module index is generated.
361+#texinfo_domain_indices = True
363+# How to display URL addresses: 'footnote', 'no', or 'inline'.
364+#texinfo_show_urls = 'footnote'
366+# If true, do not generate a @detailmenu in the "Top" node's menu.
367+#texinfo_no_detailmenu = False
370+# -- Options for Epub output ----------------------------------------------
372+# Bibliographic Dublin Core info.
375+epub_publisher = author
376+epub_copyright = copyright
378+# The basename for the epub file. It defaults to the project name.
379+#epub_basename = project
381+# The HTML theme for the epub output. Since the default themes are not optimized
382+# for small screen space, using the same theme for HTML and epub output is
383+# usually not wise. This defaults to 'epub', a theme designed to save visual
387+# The language of the text. It defaults to the language option
388+# or 'en' if the language is not set.
391+# The scheme of the identifier. Typical schemes are ISBN or URL.
394+# The unique identifier of the text. This can be a ISBN number
395+# or the project homepage.
396+#epub_identifier = ''
398+# A unique identification for the text.
401+# A tuple containing the cover image and cover page html template filenames.
404+# A sequence of (type, uri, title) tuples for the guide element of content.opf.
407+# HTML files that should be inserted before the pages created by sphinx.
408+# The format is a list of tuples containing the path and title.
411+# HTML files shat should be inserted after the pages created by sphinx.
412+# The format is a list of tuples containing the path and title.
413+#epub_post_files = []
415+# A list of files that should not be packed into the epub file.
416+epub_exclude_files = ['search.html']
418+# The depth of the table of contents in toc.ncx.
421+# Allow duplicate toc entries.
424+# Choose between 'default' and 'includehidden'.
425+#epub_tocscope = 'default'
427+# Fix unsupported image types using the Pillow.
428+#epub_fix_images = False
430+# Scale large images.
431+#epub_max_image_width = 0
433+# How to display URL addresses: 'footnote', 'no', or 'inline'.
434+#epub_show_urls = 'inline'
436+# If false, no index is generated.
437+#epub_use_index = True
docs/effects/conclusions.rstnew file+76
@@ -0,0 +1,76 @@
7+This tutorial has given an introduction to writing and reasoning about
8+side-effecting programs in Idris, using the ``Effects`` library.
9+More details about the *implementation* of the library, such as how
10+``run`` works, how handlers are invoked, etc, are given in a separate
13+Some libraries and programs which use ``Effects`` can be found in the
16+- https://github.com/edwinb/SDL-idris — some bindings for the SDL media
17+ library, supporting graphics in particular.
19+- https://github.com/edwinb/idris-demos — various demonstration
20+ programs, including several examples from this tutorial, and a “Space
23+- https://github.com/SimonJF/IdrisNet2 — networking and socket
26+- https://github.com/edwinb/Protocols — a high level communication
27+ protocol description language.
29+The inspiration for the ``Effects`` library was Bauer and Pretnar’s
30+Eff language [2]_, which describes a language based on algebraic
31+effects and handlers. Other recent languages and libraries have also
32+been built on this ideas, for example [3]_ and [4]_. The theoretical
33+foundations are also well-studied see [5]_, [6]_, [7]_, [8]_.
37+.. [1] Edwin Brady. 2013. Programming and reasoning with algebraic
38+ effects and dependent types. SIGPLAN Not. 48, 9 (September
39+ 2013), 133-144. DOI=10.1145/2544174.2500581
40+ https://dl.acm.org/citation.cfm?doid=2544174.2500581
42+.. [2] Andrej Bauer, Matija Pretnar, Programming with algebraic
43+ effects and handlers, Journal of Logical and Algebraic Methods
44+ in Programming, Volume 84, Issue 1, January 2015, Pages
45+ 108-123, ISSN 2352-2208,
46+ http://math.andrej.com/wp-content/uploads/2012/03/eff.pdf
49+.. [3] Ben Lippmeier. 2009. Witnessing Purity, Constancy and
50+ Mutability. In Proceedings of the 7th Asian Symposium on
51+ Programming Languages and Systems (APLAS '09), Zhenjiang Hu
52+ (Ed.). Springer-Verlag, Berlin, Heidelberg,
53+ 95-110. DOI=10.1007/978-3-642-10672-9_9
54+ https://link.springer.com/chapter/10.1007%2F978-3-642-10672-9_9
57+.. [4] Ohad Kammar, Sam Lindley, and Nicolas Oury. 2013. Handlers in
58+ action. SIGPLAN Not. 48, 9 (September 2013),
59+ 145-158. DOI=10.1145/2544174.2500590
60+ https://dl.acm.org/citation.cfm?doid=2544174.2500590
62+.. [5] Martin Hyland, Gordon Plotkin, John Power, Combining effects:
63+ Sum and tensor, Theoretical Computer Science, Volume 357,
64+ Issues 1–3, 25 July 2006, Pages 70-99, ISSN 0304-3975,
65+ (https://www.sciencedirect.com/science/article/pii/S0304397506002659)
67+.. [6] Paul Blain Levy. 2004. Call-By-Push-Value: A
68+ Functional/Imperative Synthesis (Semantics Structures in
69+ Computation, V. 2). Kluwer Academic Publishers, Norwell, MA,
72+.. [7] Plotkin, Gordon, and Matija Pretnar. "Handlers of algebraic
73+ effects." Programming Languages and Systems. Springer Berlin
74+ Heidelberg, 2009. 80-94.
76+.. [8] Pretnar, Matija. "Logic and handling of algebraic effects." (2010).
docs/effects/depeff.rstnew file+342
@@ -0,0 +1,342 @@
7+In the programs we have seen so far, the available effects have remained
8+constant. Sometimes, however, an operation can *change* the available
9+effects. The simplest example occurs when we have a state with a
10+dependent type—adding an element to a vector also changes its type, for
11+example, since its length is explicit in the type. In this section, we
12+will see how the library supports this. Firstly, we will see how states
13+with dependent types can be implemented. Secondly, we will see how the
14+effects can depend on the *result* of an effectful operation. Finally,
15+we will see how this can be used to implement a type-safe and
16+resource-safe protocol for file management.
21+Suppose we have a function which reads input from the console, converts
22+it to an integer, and adds it to a list which is stored in a ``STATE``.
23+It might look something like the following:
27+ readInt : Eff () [STATE (List Int), STDIO]
28+ readInt = do let x = trim !getStr
31+But what if, instead of a list of integers, we would like to store a
32+``Vect``, maintaining the length in the type?
36+ readInt : Eff () [STATE (Vect n Int), STDIO]
37+ readInt = do let x = trim !getStr
40+This will not type check! Although the vector has length ``n`` on entry
41+to ``readInt``, it has length ``S n`` on exit. The library allows us to
42+express this as follows:
46+ readInt : Eff () [STATE (Vect n Int), STDIO]
47+ [STATE (Vect (S n) Int), STDIO]
48+ readInt = do let x = trim !getStr
49+ putM (cast x :: !get)
51+The type ``Eff a xs xs'`` means that the operation
52+begins with effects ``xs`` available, and ends with effects ``xs’``
53+available. We have used ``putM`` to update the state, where the ``M``
54+suffix indicates that the *type* is being updated as well as the value.
55+It has the following type:
59+ putM : y -> Eff () [STATE x] [STATE y]
61+Result-dependent Effects
62+========================
64+Often, whether a state is updated could depend on the success or
65+otherwise of an operation. In our ``readInt`` example, we might wish to
66+update the vector only if the input is a valid integer (i.e. all
67+digits). As a first attempt, we could try the following, returning a
68+``Bool`` which indicates success:
72+ readInt : Eff Bool [STATE (Vect n Int), STDIO]
73+ [STATE (Vect (S n) Int), STDIO]
74+ readInt = do let x = trim !getStr
75+ case all isDigit (unpack x) of
77+ True => do putM (cast x :: !get)
80+Unfortunately, this will not type check because the vector does not get
81+extended in both branches of the ``case``!
85+ MutState.idr:18:19:When elaborating right hand side of Main.case
87+ Unifying n and S n would lead to infinite value
89+Clearly, the size of the resulting vector depends on whether or not the
90+value read from the user was valid. We can express this in the type:
94+ readInt : Eff Bool [STATE (Vect n Int), STDIO]
95+ (\ok => if ok then [STATE (Vect (S n) Int), STDIO]
96+ else [STATE (Vect n Int), STDIO])
97+ readInt = do let x = trim !getStr
98+ case all isDigit (unpack x) of
100+ True => do putM (cast x :: !get)
103+Using ``pureM`` rather than ``pure`` allows the output effects to be
104+calculated from the value given. Its type is:
106+.. code-block:: idris
108+ pureM : (val : a) -> EffM m a (xs val) xs
110+When using ``readInt``, we will have to check its return
111+value in order to know what the new set of effects is. For example, to
112+read a set number of values into a vector, we could write the following:
114+.. code-block:: idris
116+ readN : (n : Nat) ->
117+ Eff () [STATE (Vect m Int), STDIO]
118+ [STATE (Vect (n + m) Int), STDIO]
120+ readN {m} (S k) = case !readInt of
121+ True => rewrite plusSuccRightSucc k m in readN k
122+ False => readN (S k)
124+The ``case`` analysis on the result of ``readInt`` means that we know in
125+each branch whether reading the integer succeeded, and therefore how
126+many values still need to be read into the vector. What this means in
127+practice is that the type system has verified that a necessary dynamic
128+check (i.e. whether reading a value succeeded) has indeed been done.
131+ Only ``case`` will work here. We cannot use ``if/then/else``
132+ because the ``then`` and ``else`` branches must have the same
133+ type. The ``case`` construct, however, abstracts over the value
134+ being inspected in the type of each branch.
139+A practical use for dependent effects is in specifying resource usage
140+protocols and verifying that they are executed correctly. For example,
141+file management follows a resource usage protocol with the following
142+(informally specified) requirements:
144+- It is necessary to open a file for reading before reading it
146+- Opening may fail, so the programmer should check whether opening was
149+- A file which is open for reading must not be written to, and vice
152+- When finished, an open file handle should be closed
154+- When a file is closed, its handle should no longer be used
156+These requirements can be expressed formally by creating a
157+``FILE_IO`` effect parameterised over a file handle state, which is
158+either empty, open for reading, or open for writing. The ``FILE_IO``
159+effect’s definition is given below.
162+ This effect is mainly for illustrative purposes.
163+ Typically we would also like to support random access files and
164+ better reporting of error conditions.
166+ Moreover, the ``FILE`` effect in the ``Effect.File`` module of
167+ the ``effects`` library uses slightly more complicated types to
168+ support erroneous behaviour of each function and to support more
169+ compilcated modes of opening, like for reading **and** writing,
170+ appending or truncating.
172+.. code-block:: idris
177+ import Control.IOExcept
179+ FILE_IO : Type -> EFFECT
181+ data OpenFile : Mode -> Type
183+ open : (fname : String)
185+ -> Eff Bool [FILE_IO ()]
186+ (\res => [FILE_IO (case res of
189+ close : Eff () [FILE_IO (OpenFile m)] [FILE_IO ()]
191+ readLine : Eff String [FILE_IO (OpenFile Read)]
192+ writeLine : String -> Eff () [FILE_IO (OpenFile Write)]
193+ eof : Eff Bool [FILE_IO (OpenFile Read)]
195+ Handler FileIO IO where { ... }
197+In particular, consider the type of ``open``:
199+.. code-block:: idris
201+ open : (fname : String)
203+ -> Eff Bool [FILE_IO ()]
204+ (\res => [FILE_IO (case res of
208+This returns a ``Bool`` which indicates whether opening the file was
209+successful. The resulting state depends on whether the operation was
210+successful; if so, we have a file handle open for the stated purpose,
211+and if not, we have no file handle. By ``case`` analysis on the result,
212+we continue the protocol accordingly.
215+.. code-block:: idris
217+ readFile : Eff (List String) [FILE_IO (OpenFile Read)]
218+ readFile = readAcc [] where
219+ readAcc : List String -> Eff (List String) [FILE_IO (OpenFile Read)]
220+ readAcc acc = if (not !eof)
221+ then readAcc (!readLine :: acc)
222+ else pure (reverse acc)
224+Given a function ``readFile``, above, which reads from
225+an open file until reaching the end, we can write a program which opens
226+a file, reads it, then displays the contents and closes it, as follows,
227+correctly following the protocol:
229+.. code-block:: idris
231+ dumpFile : String -> Eff () [FILE_IO (), STDIO]
232+ dumpFile name = case !(open name Read) of
233+ True => do putStrLn (show !readFile)
235+ False => putStrLn ("Error!")
237+The type of ``dumpFile``, with ``FILE_IO ()`` in its effect list,
238+indicates that any use of the file resource will follow the protocol
239+correctly (i.e. it both begins and ends with an empty resource). If we
240+fail to follow the protocol correctly (perhaps by forgetting to close
241+the file, failing to check that ``open`` succeeded, or opening the file
242+for writing) then we will get a compile-time error. For example,
243+changing ``open name Read`` to ``open name Write`` yields a compile-time
244+error of the following form:
248+ FileTest.idr:16:18:When elaborating right hand side of Main.case
251+ SubList [(FILE_IO (OpenFile Read))]
252+ [(FILE_IO (OpenFile Write)), STDIO]
254+In other words: when reading a file, we need a file which is open for
255+reading, but the effect list contains a ``FILE_IO`` effect carrying a
256+file open for writing.
258+Pattern-matching bind
259+=====================
261+It might seem that having to test each potentially failing operation
262+with a ``case`` clause could lead to ugly code, with lots of
263+nested case blocks. Many languages support exceptions to improve this,
264+but unfortunately exceptions may not allow completely clean resource
265+management—for example, guaranteeing that any ``open`` which did succeed
266+has a corresponding close.
268+Idris supports *pattern-matching* bindings, such as the following:
270+.. code-block:: idris
272+ dumpFile : String -> Eff () [FILE_IO (), STDIO]
273+ dumpFile name = do True <- open name Read
274+ putStrLn (show !readFile)
277+This also has a problem: we are no longer dealing with the case where
278+opening a file failed! The solution is to extend the pattern-matching
279+binding syntax to give brief clauses for failing matches. Here, for
280+example, we could write:
282+.. code-block:: idris
284+ dumpFile : String -> Eff () [FILE_IO (), STDIO]
285+ dumpFile name = do True <- open name Read | False => putStrLn "Error"
286+ putStrLn (show !readFile)
289+This is exactly equivalent to the definition with the explicit ``case``.
290+In general, in a ``do``-block, the syntax:
292+.. code-block:: idris
294+ do pat <- val | <alternatives>
299+.. code-block:: idris
306+There can be several ``alternatives``, separated by a vertical bar
307+``|``. For example, there is a ``SYSTEM`` effect which supports
308+reading command line arguments, among other things (see Appendix
309+:ref:`sect-appendix`). To read command line arguments, we can use
312+.. code-block:: idris
314+ getArgs : Eff (List String) [SYSTEM]
316+A main program can read command line arguments as follows, where in the
317+list which is returned, the first element ``prog`` is the executable
318+name and the second is an expected argument:
320+.. code-block:: idris
322+ emain : Eff () [SYSTEM, STDIO]
323+ emain = do [prog, arg] <- getArgs
324+ putStrLn $ "Argument is " ++ arg
325+ {- ... rest of function ... -}
327+Unfortunately, this will not fail gracefully if no argument is given, or
328+if too many arguments are given. We can use pattern matching bind
329+alternatives to give a better (more informative) error:
331+.. code-block:: idris
333+ emain : Eff () [SYSTEM, STDIO]
334+ emain = do [prog, arg] <- getArgs | [] => putStrLn "Can't happen!"
335+ | [prog] => putStrLn "No arguments!"
336+ | _ => putStrLn "Too many arguments!"
337+ putStrLn $ "Argument is " ++ arg
338+ {- ... rest of function ... -}
340+If ``getArgs`` does not return something of the form ``[prog, arg]`` the
341+alternative which does match is executed instead, and that value
docs/effects/hangman.rstnew file+329
@@ -0,0 +1,329 @@
3+***************************************
4+Example: A “Mystery Word” Guessing Game
5+***************************************
7+In this section, we will use the techniques and specific effects
8+discussed in the tutorial so far to implement a larger example, a simple
9+text-based word-guessing game. In the game, the computer chooses a word,
10+which the player must guess letter by letter. After a limited number of
11+wrong guesses, the player loses [1]_.
13+We will implement the game by following these steps:
15+#. Define the game state, in enough detail to express the rules
17+#. Define the rules of the game (i.e. what actions the player may take,
18+ and how these actions affect the game state)
20+#. Implement the rules of the game (i.e. implement state updates for
23+#. Implement a user interface which allows a player to direct actions
25+Step 2 may be achieved by defining an effect which depends on the state
26+defined in step 1. Then step 3 involves implementing a ``Handler`` for
27+this effect. Finally, step 4 involves implementing a program in ``Eff``
28+using the newly defined effect (and any others required to implement the
34+First, we categorise the game states as running games (where there are a
35+number of guesses available, and a number of letters still to guess), or
36+non-running games (i.e. games which have not been started, or games
37+which have been won or lost).
41+ data GState = Running Nat Nat | NotRunning
43+Notice that at this stage, we say nothing about what it means to make a
44+guess, what the word to be guessed is, how to guess letters, or any
45+other implementation detail. We are only interested in what is necessary
46+to describe the game rules.
48+We will, however, parameterise a concrete game state ``Mystery`` over
53+ data Mystery : GState -> Type
58+We describe the game rules as a dependent effect, where each action has
59+a *precondition* (i.e. what the game state must be before carrying out
60+the action) and a *postcondition* (i.e. how the action affects the game
61+state). Informally, these actions with the pre- and postconditions are:
64+ Guess a letter in the word.
66+ - Precondition: The game must be running, and there must be both
67+ guesses still available, and letters still to be guessed.
69+ - Postcondition: If the guessed letter is in the word and not yet
70+ guessed, reduce the number of letters, otherwise reduce the
76+ - Precondition: The game must be running, and there must be no
77+ letters still to be guessed.
79+ - Postcondition: The game is no longer running.
84+ - Precondition: The game must be running, and there must be no
87+ - Postcondition: The game is no longer running.
90+ Set a new word to be guessed
92+ - Precondition: The game must not be running.
94+ - Postcondition: The game is running, with 6 guesses available (the
95+ choice of 6 is somewhat arbitrary here) and the number of unique
96+ letters in the word still to be guessed.
99+ Get a string representation of the game state. This is for display
100+ purposes; there are no pre- or postconditions.
102+We can make these rules precise by declaring them more formally in an
105+.. code-block:: idris
107+ data MysteryRules : Effect where
108+ Guess : (x : Char) ->
109+ sig MysteryRules Bool
110+ (Mystery (Running (S g) (S w)))
111+ (\inword => if inword
112+ then Mystery (Running (S g) w)
113+ else Mystery (Running g (S w)))
114+ Won : sig MysteryRules () (Mystery (Running g 0))
115+ (Mystery NotRunning)
116+ Lost : sig MysteryRules () (Mystery (Running 0 g))
117+ (Mystery NotRunning)
118+ NewWord : (w : String) ->
119+ sig MysteryRules () (Mystery NotRunning) (Mystery (Running 6 (length (letters w))))
120+ Get : sig MysteryRules String (Mystery h)
122+This description says nothing about how the rules are implemented. In
123+particular, it does not specify *how* to tell whether a guessed letter
124+was in a word, just that the result of ``Guess`` depends on it.
126+Nevertheless, we can still create an ``EFFECT`` from this, and use it in
127+an ``Eff`` program. Implementing a ``Handler`` for ``MysteryRules`` will
128+then allow us to play the game.
130+.. code-block:: idris
132+ MYSTERY : GState -> EFFECT
133+ MYSTERY h = MkEff (Mystery h) MysteryRules
135+Step 3: Implement Rules
136+=======================
138+To *implement* the rules, we begin by giving a concrete definition of
141+.. code-block:: idris
143+ data Mystery : GState -> Type where
144+ Init : Mystery NotRunning
145+ GameWon : (word : String) -> Mystery NotRunning
146+ GameLost : (word : String) -> Mystery NotRunning
147+ MkG : (word : String) ->
149+ (got : List Char) ->
150+ (missing : Vect m Char) ->
151+ Mystery (Running guesses m)
153+If a game is ``NotRunning``, that is either because it has not yet
154+started (``Init``) or because it is won or lost (``GameWon`` and
155+``GameLost``, each of which carry the word so that showing the game
156+state will reveal the word to the player). Finally, ``MkG`` captures a
157+running game’s state, including the target word, the letters
158+successfully guessed, and the missing letters. Using a ``Vect`` for the
159+missing letters is convenient since its length is used in the type.
161+To initialise the state, we implement the following functions:
162+``letters``, which returns a list of unique letters in a ``String``
163+(ignoring spaces) and ``initState`` which sets up an initial state
164+considered valid as a postcondition for ``NewWord``.
166+.. code-block:: idris
168+ letters : String -> List Char
169+ initState : (x : String) -> Mystery (Running 6 (length (letters x)))
171+When checking if a guess is in the vector of missing letters, it is
172+convenient to return a *proof* that the guess is in the vector, using
173+``isElem`` below, rather than merely a ``Bool``:
175+.. code-block:: idris
177+ data IsElem : a -> Vect n a -> Type where
178+ First : IsElem x (x :: xs)
179+ Later : IsElem x xs -> IsElem x (y :: xs)
181+ isElem : DecEq a => (x : a) -> (xs : Vect n a) -> Maybe (IsElem x xs)
183+The reason for returning a proof is that we can use it to remove an
184+element from the correct position in a vector:
186+.. code-block:: idris
188+ shrink : (xs : Vect (S n) a) -> IsElem x xs -> Vect n a
190+We leave the definitions of ``letters``, ``init``, ``isElem`` and
191+``shrink`` as exercises. Having implemented these, the ``Handler``
192+implementation for ``MysteryRules`` is surprisingly straightforward:
194+.. code-block:: idris
196+ Handler MysteryRules m where
197+ handle (MkG w g got []) Won k = k () (GameWon w)
198+ handle (MkG w Z got m) Lost k = k () (GameLost w)
200+ handle st Get k = k (show st) st
201+ handle st (NewWord w) k = k () (initState w)
203+ handle (MkG w (S g) got m) (Guess x) k =
205+ Nothing => k False (MkG w _ got m)
206+ (Just p) => k True (MkG w _ (x :: got) (shrink m p))
208+Each case simply involves directly updating the game state in a way
209+which is consistent with the declared rules. In particular, in
210+``Guess``, if the handler claims that the guessed letter is in the word
211+(by passing ``True`` to ``k``), there is no way to update the state in
212+such a way that the number of missing letters or number of guesses does
213+not follow the rules.
215+Step 4: Implement Interface
216+===========================
218+Having described the rules, and implemented state transitions which
219+follow those rules as an effect handler, we can now write an interface
220+for the game which uses the ``MYSTERY`` effect:
222+.. code-block:: idris
224+ game : Eff () [MYSTERY (Running (S g) w), STDIO]
225+ [MYSTERY NotRunning, STDIO]
227+The type indicates that the game must start in a running state, with
228+some guesses available, and eventually reach a not-running state (i.e.
229+won or lost). The only way to achieve this is by correctly following the
232+Note that the type of ``game`` makes no assumption that there are
233+letters to be guessed in the given word (i.e. it is ``w`` rather than
234+``S w``). This is because we will be choosing a word at random from a
235+vector of ``String``, and at no point have we made it explicit that
236+those ``String`` are non-empty.
238+Finally, we need to initialise the game by picking a word at random from
239+a list of candidates, setting it as the target using ``NewWord``, then
242+.. code-block:: idris
244+ runGame : Eff () [MYSTERY NotRunning, RND, SYSTEM, STDIO]
245+ runGame = do srand !time
246+ let w = index !(rndFin _) words
249+ putStrLn !(call Get)
251+We use the system time (``time`` from the ``SYSTEM`` effect; see
252+Appendix :ref:`sect-appendix`) to initialise the random number
253+generator, then pick a random ``Fin`` to index into a list of
254+``words``. For example, we could initialise a word list as follows:
256+.. code-block:: idris
259+ words = with Vect ["idris","agda","haskell","miranda",
260+ "java","javascript","fortran","basic",
261+ "coffeescript","rust"]
263+ wtype = proof search
266+ Rather than have to explicitly declare a type with the vector’s
267+ length, it is convenient to give a hole ``?wtype`` and let
268+ Idris’s proof search mechanism find the type. This is a
269+ limited form of type inference, but very useful in practice.
271+A possible complete implementation of ``game`` is
274+.. code-block:: idris
276+ game : Eff () [MYSTERY (Running (S g) w), STDIO]
277+ [MYSTERY NotRunning, STDIO]
281+ putStr "Enter guess: "
282+ let guess = trim !getStr
283+ case choose (not (guess == "")) of
284+ (Left p) => processGuess (strHead' guess p)
285+ (Right p) => do putStrLn "Invalid input!"
288+ processGuess : Char -> Eff () [MYSTERY (Running (S g) (S w)), STDIO]
289+ [MYSTERY NotRunning, STDIO]
290+ processGuess {g} {w} c
291+ = case !(Main.Guess c) of
292+ True => do putStrLn "Good guess!"
296+ False => do putStrLn "No, sorry"
304+Writing the rules separately as an effect, then an implementation
305+which uses that effect, ensures that the implementation must follow
306+the rules. This has practical applications in more serious contexts;
307+``MysteryRules`` for example can be though of as describing a
308+*protocol* that a game player most follow, or alternative a
309+*precisely-typed API*.
311+In practice, we wouldn’t really expect to write rules first then
312+implement the game once the rules were complete. Indeed, I didn’t do
313+so when constructing this example! Rather, I wrote down a set of
314+likely rules making any assumptions *explicit* in the state
315+transitions for ``MysteryRules``. Then, when implementing ``game`` at
316+first, any incorrect assumption was caught as a type error. The
317+following errors were caught during development:
319+- Not realising that allowing ``NewWord`` to be an arbitrary string would mean that ``game`` would have to deal with a zero-length word as a starting state.
321+- Forgetting to check whether a game was won before recursively calling ``processGuess``, thus accidentally continuing a finished game.
323+- Accidentally checking the number of missing letters, rather than the number of remaining guesses, when checking if a game was lost.
325+These are, of course, simple errors, but were caught by the type
326+checker before any testing of the game.
329+ Readers may recognise this game by the name “Hangman”.
docs/effects/impleff.rstnew file+333
@@ -0,0 +1,333 @@
7+We have now seen several side-effecting operations provided by the
8+``Effects`` library, and examples of their use in Section
9+:ref:`sect-simpleff`. We have also seen how operations may *modify*
10+the available effects by changing state in Section
11+:ref:`sect-depeff`. We have not, however, yet seen how these
12+operations are implemented. In this section, we describe how a
13+selection of the available effects are implemented, and show how new
14+effectful operations may be provided.
19+Effects are described by *algebraic data types*, where the
20+constructors describe the operations provided when the effect is
21+available. Stateful operations are described as follows:
25+ data State : Effect where
26+ Get : State a a (\x => a)
27+ Put : b -> State () a (\x => b)
29+``Effect`` itself is a type synonym, giving the required type for an
35+ Effect = (result : Type) ->
36+ (input_resource : Type) ->
37+ (output_resource : result -> Type) -> Type
39+Each effect is associated with a *resource*. The second argument to
40+an effect signature is the resource type on *input* to an operation,
41+and the third is a function which computes the resource type on
42+*output*. Here, it means:
44+- ``Get`` takes no arguments. It has a resource of type ``a``, which is not updated, and running the ``Get`` operation returns something of type ``a``.
46+- ``Put`` takes a ``b`` as an argument. It has a resource of type ``a`` on input, which is updated to a resource of type ``b``. Running the ``Put`` operation returns the element of the unit type.
48+The effects library provides an overloaded function ``sig``
49+which can make effect signatures more concise, particularly when the
50+result has no effect on the resource type. For ``State``, we can
55+ data State : Effect where
57+ Put : b -> sig State () a b
59+There are four versions of ``sig``, depending on whether we
60+are interested in the resource type, and whether we are updating the
61+resource. Idris will infer the appropriate version from usage.
65+ NoResourceEffect.sig : Effect -> Type -> Type
66+ NoUpdateEffect.sig : Effect -> (ret : Type) ->
67+ (resource : Type) -> Type
68+ UpdateEffect.sig : Effect -> (ret : Type) ->
69+ (resource_in : Type) ->
70+ (resource_out : Type) -> Type
71+ DepUpdateEffect.sig : Effect -> (ret : Type) ->
72+ (resource_in : Type) ->
73+ (resource_out : ret -> Type) -> Type
75+In order to convert ``State`` (of type ``Effect``) into something
76+usable in an effects list, of type ``EFFECT``, we write the following:
80+ STATE : Type -> EFFECT
81+ STATE t = MkEff t State
83+``MkEff`` constructs an ``EFFECT`` by taking the resource type (here,
84+the ``t`` which parameterises ``STATE``) and the effect signature
85+(here, ``State``). For reference, ``EFFECT`` is declared as follows:
89+ data EFFECT : Type where
90+ MkEff : Type -> Effect -> EFFECT
92+Recall that to run an effectful program in ``Eff``, we use one of the
93+``run`` family of functions to run the program in a particular
94+computation context ``m``. For each effect, therefore, we must explain
95+how it is executed in a particular computation context for ``run`` to
96+work in that context. This is achieved with the following interface:
100+ interface Handler (e : Effect) (m : Type -> Type) where
101+ handle : resource -> (eff : e t resource resource') ->
102+ ((x : t) -> resource' x -> m a) -> m a
104+We have already seen some implementation declarations in the effect
105+summaries in Section :ref:`sect-simpleff`. An implementation of ``Handler e
106+m`` means that the effect declared with signature ``e`` can be run in
107+computation context ``m``. The ``handle`` function takes:
109+- The ``resource`` on input (so, the current value of the state for ``State``)
111+- The effectful operation (either ``Get`` or ``Put x`` for ``State``)
113+- A *continuation*, which we conventionally call ``k``, and should be passed the result value of the operation, and an updated resource.
115+There are two reasons for taking a continuation here: firstly, this is
116+neater because there are multiple return values (a new resource and
117+the result of the operation); secondly, and more importantly, the
118+continuation can be called zero or more times.
120+A ``Handler`` for ``State`` simply passes on the value of the state,
121+in the case of ``Get``, or passes on a new state, in the case of
122+``Put``. It is defined the same way for all computation contexts:
124+.. code-block:: idris
126+ Handler State m where
127+ handle st Get k = k st st
128+ handle st (Put n) k = k () n
130+This gives enough information for ``Get`` and ``Put`` to be used
131+directly in ``Eff`` programs. It is tidy, however, to define top level
132+functions in ``Eff``, as follows:
134+.. code-block:: idris
136+ get : Eff x [STATE x]
139+ put : x -> Eff () [STATE x]
140+ put val = call (Put val)
142+ putM : y -> Eff () [STATE x] [STATE y]
143+ putM val = call (Put val)
145+**An implementation detail (aside):** The ``call`` function converts
146+an ``Effect`` to a function in ``Eff``, given a proof that the effect
147+is available. This proof can be constructed automatically, since
148+it is essentially an index into a statically known list of effects:
150+.. code-block:: idris
152+ call : {e : Effect} ->
153+ (eff : e t a b) -> {auto prf : EffElem e a xs} ->
154+ Eff t xs (\v => updateResTy v xs prf eff)
156+This is the reason for the ``Can’t solve goal`` error when an effect
157+is not available: the implicit proof ``prf`` has not been solved
158+automatically because the required effect is not in the list of
161+Such details are not important for using the library, or even writing
162+new effects, however.
167+The following listing summarises what is required to define the
170+.. code-block:: idris
172+ data State : Effect where
174+ Put : b -> sig State () a b
176+ STATE : Type -> EFFECT
177+ STATE t = MkEff t State
179+ Handler State m where
180+ handle st Get k = k st st
181+ handle st (Put n) k = k () n
183+ get : Eff x [STATE x]
186+ put : x -> Eff () [STATE x]
187+ put val = call (Put val)
189+ putM : y -> Eff () [STATE x] [STATE y]
190+ putM val = call (Put val)
196+Then listing below gives the definition of the ``STDIO``
197+effect, including handlers for ``IO`` and ``IOExcept``. We omit the
198+definition of the top level ``Eff`` functions, as this merely invoke
199+the effects ``PutStr``, ``GetStr``, ``PutCh`` and ``GetCh`` directly.
201+Note that in this case, the resource is the unit type in every case,
202+since the handlers merely apply the ``IO`` equivalents of the effects
206+.. code-block:: idris
208+ data StdIO : Effect where
209+ PutStr : String -> sig StdIO ()
210+ GetStr : sig StdIO String
211+ PutCh : Char -> sig StdIO ()
212+ GetCh : sig StdIO Char
214+ Handler StdIO IO where
215+ handle () (PutStr s) k = do putStr s; k () ()
216+ handle () GetStr k = do x <- getLine; k x ()
217+ handle () (PutCh c) k = do putChar c; k () ()
218+ handle () GetCh k = do x <- getChar; k x ()
220+ Handler StdIO (IOExcept a) where
221+ handle () (PutStr s) k = do ioe_lift $ putStr s; k () ()
222+ handle () GetStr k = do x <- ioe_lift $ getLine; k x ()
223+ handle () (PutCh c) k = do ioe_lift $ putChar c; k () ()
224+ handle () GetCh k = do x <- ioe_lift $ getChar; k x ()
227+ STDIO = MkEff () StdIO
232+The listing below gives the definition of the ``Exception``
233+effect, including two of its handlers for ``Maybe`` and ``List``. The
234+only operation provided is ``Raise``. The key point to note in the
235+definitions of these handlers is that the continuation ``k`` is not
236+used. Running ``Raise`` therefore means that computation stops with an
239+.. code-block:: idris
241+ data Exception : Type -> Effect where
242+ Raise : a -> sig (Exception a) b
244+ Handler (Exception a) Maybe where
245+ handle _ (Raise e) k = Nothing
247+ Handler (Exception a) List where
248+ handle _ (Raise e) k = []
250+ EXCEPTION : Type -> EFFECT
251+ EXCEPTION t = MkEff () (Exception t)
257+The following listing gives the definition of the ``Select``
258+effect for writing non-deterministic programs, including a handler for
259+``List`` context which returns all possible successful values, and a
260+handler for ``Maybe`` context which returns the first successful
263+.. code-block:: idris
265+ data Selection : Effect where
266+ Select : List a -> sig Selection a
268+ Handler Selection Maybe where
269+ handle _ (Select xs) k = tryAll xs where
271+ tryAll (x :: xs) = case k x () of
272+ Nothing => tryAll xs
275+ Handler Selection List where
276+ handle r (Select xs) k = concatMap (\x => k x r) xs
279+ SELECT = MkEff () Selection
282+Here, the continuation is called multiple times in each handler, for
283+each value in the list of possible values. In the ``List`` handler, we
284+accumulate all successful results, and in the ``Maybe`` handler we try
285+the first value in the list, and try later values only if that fails.
290+Result-dependent effects are no different from non-dependent effects
291+in the way they are implemented. The listing below
292+illustrates this for the ``FILE_IO`` effect. The syntax for state
293+transitions ``{ x ==> {res} x’ }``, where the result state ``x’`` is
294+computed from the result of the operation ``res``, follows that for
295+the equivalent ``Eff`` programs.
297+.. code-block:: idris
299+ data FileIO : Effect where
300+ Open : (fname: String)
302+ -> sig FileIO Bool () (\res => case res of
305+ Close : sig FileIO () (OpenFile m)
307+ ReadLine : sig FileIO String (OpenFile Read)
308+ WriteLine : String -> sig FileIO () (OpenFile Write)
309+ EOF : sig FileIO Bool (OpenFile Read)
311+ Handler FileIO IO where
312+ handle () (Open fname m) k = do h <- openFile fname m
316+ handle (FH h) Close k = do closeFile h
319+ handle (FH h) ReadLine k = do str <- fread h
321+ handle (FH h) (WriteLine str) k = do fwrite h str
323+ handle (FH h) EOF k = do e <- feof h
326+ FILE_IO : Type -> EFFECT
327+ FILE_IO t = MkEff t FileIO
329+Note that in the handler for ``Open``, the types passed to the
330+continuation ``k`` are different depending on whether the result is
331+``True`` (opening succeeded) or ``False`` (opening failed). This uses
332+``validFile``, defined in the ``Prelude``, to test whether a file
333+handler refers to an open file or not.
docs/effects/index.rstnew file+40
@@ -0,0 +1,40 @@
1+.. _eff-tutorial-index:
7+A tutorial on the `Effects` package in `Idris`.
9+.. topic:: Effects and the ``Control.ST`` module
11+ There is a new module in the ``contrib`` package, ``Control.ST``, which
12+ provides the resource tracking facilities of `Effects` but with
13+ better support for creating and deleting resources, and implementing
14+ resources in terms of other resources.
16+ Unless you have a particular reason to use `Effects` you are strongly
17+ recommended to use ``Control.ST`` instead. There is a tutorial available
18+ on this site for ``Control.ST`` with several examples
19+ (:ref:`st-tutorial-index`).
23+ The documentation for Idris has been published under the Creative
24+ Commons CC0 License. As such to the extent possible under law, *The
25+ Idris Community* has waived all copyright and related or neighbouring
26+ rights to Documentation for Idris.
28+ More information concerning the CC0 can be found online at: https://creativecommons.org/publicdomain/zero/1.0/
docs/effects/introduction.rstnew file+110
@@ -0,0 +1,110 @@
5+Pure functional languages with dependent types such as `Idris
6+<https://www.idris-lang.org/>`_ support reasoning about programs directly
7+in the type system, promising that we can *know* a program will run
8+correctly (i.e. according to the specification in its type) simply
9+because it compiles. Realistically, though, things are not so simple:
10+programs have to interact with the outside world, with user input,
11+input from a network, mutable state, and so on. In this tutorial I
12+will introduce the library, which is included with the distribution
13+and supports programming and reasoning with side-effecting programs,
14+supporting mutable state, interaction with the outside world,
15+exceptions, and verified resource management.
17+This tutorial assumes familiarity with pure programming in Idris,
18+as described in Sections 1–6 of the main tutorial [1]_. The examples
19+presented are tested with Idris and can be found in the
20+examples directory of the Idris repository. The ``-p effects`` flag
21+is needed when starting Idris.
23+Consider, for example, the following introductory function which
24+illustrates the kind of properties which can be expressed in the type
29+ vadd : Vect n Int -> Vect n Int -> Vect n Int
31+ vadd (x :: xs) (y :: ys) = x + y :: vadd xs ys
33+This function adds corresponding elements in a pair of vectors. The type
34+guarantees that the vectors will contain only elements of type ``Int``,
35+and that the input lengths and the output length all correspond. A
36+natural question to ask here, which is typically neglected by
37+introductory tutorials, is “How do I turn this into a program?” That is,
38+given some lists entered by a user, how do we get into a position to be
39+able to apply the ``vadd`` function? Before doing so, we will have to:
41+- Read user input, either from the keyboard, a file, or some other input device.
43+- Check that the user inputs are valid, i.e. contain only ``Int`` and are the same length, and report an error if not.
47+The complete program will include side-effects for I/O and error
48+handling, before we can get to the pure core functionality. In this
49+tutorial, we will see how Idris supports side-effects.
50+Furthermore, we will see how we can use the dependent type system to
51+*reason* about stateful and side-effecting programs. We will return to
52+this specific example later.
57+To give an idea of how programs with effects look, here is the
58+ubiquitous “Hello world” program, written using the ``Effects``
68+ hello : Eff () [STDIO]
69+ hello = putStrLn "Hello world!"
74+As usual, the entry point is ``main``. All ``main`` has to do is invoke the
75+``hello`` function which supports the ``STDIO`` effect for console I/O, and
76+returns the unit value. All programs using the ``Effects`` library must
77+``import Effects``. The details of the ``Eff`` type will be presented in the
78+remainder of this tutorial.
80+To compile and run this program, Idris needs to be told to include
81+the ``Effects`` package, using the ``-p effects`` flag (this flag is
82+required for all examples in this tutorial):
86+ idris hello.idr -o hello -p effects
92+The tutorial is structured as follows: first, in Section
93+:ref:`sect-state`, we will discuss state management, describing why it
94+is important and introducing the ``effects`` library to show how it
95+can be used to manage state. This section also gives an overview of
96+the syntax of effectful programs. Section :ref:`sect-simpleff` then
97+introduces a number of other effects a program may have: I/O;
98+Exceptions; Random Numbers; and Non-determinism, giving examples for
99+each, and an extended example combining several effects in one
100+complete program. Section :ref:`sect-depeff` introduces *dependent*
101+effects, showing how states and resources can be managed in
102+types. Section :ref:`sect-impleff` shows how new effects can be
103+implemented. Section :ref:`sect-hangman` gives an extended example
104+showing how to implement a “mystery word” guessing game, using effects
105+to describe the rules of the game and ensure they are implemented
106+accurately. References to further reading are given in Section
110+ You do not, however, need to know what a monad is!
docs/effects/simpleeff.rstnew file+595
@@ -0,0 +1,595 @@
7+So far we have seen how to write programs with locally mutable state
8+using the ``STATE`` effect. To recap, we have the definitions below
9+in a module ``Effect.State``
15+ STATE : Type -> EFFECT
17+ get : Eff x [STATE x]
18+ put : x -> Eff () [STATE x]
19+ putM : y -> Eff () [STATE x] [STATE y]
20+ update : (x -> x) -> Eff () [STATE x]
22+ Handler State m where { ... }
24+The last line, ``Handler State m where { ... }``, means that the ``STATE``
25+effect is usable in any computation context ``m``. That is, a program
26+which uses this effect and returns something of type ``a`` can be
27+evaluated to something of type ``m a`` using ``run``, for any
28+``m``. The lower case ``State`` is a data type describing the
29+operations which make up the ``STATE`` effect itself—we will go into
30+more detail about this in Section :ref:`sect-impleff`.
32+In this section, we will introduce some other supported effects,
33+allowing console I/O, exceptions, random number generation and
34+non-deterministic programming. For each effect we introduce, we will
35+begin with a summary of the effect, its supported operations, and the
36+contexts in which it may be used, like that above for ``STATE``, and
37+go on to present some simple examples. At the end, we will see some
38+examples of programs which combine multiple effects.
40+All of the effects in the library, including those described in this
41+section, are summarised in Appendix :ref:`sect-appendix`.
46+Console I/O is supported with the ``STDIO``
47+effect, which allows reading and writing characters and strings to and
48+from standard input and standard output. Notice that there is a
49+constraint here on the computation context ``m``, because it only
50+makes sense to support console I/O operations in a context where we
51+can perform (or at the very least simulate) console I/O:
59+ putChar : Char -> Eff () [STDIO]
60+ putStr : String -> Eff () [STDIO]
61+ putStrLn : String -> Eff () [STDIO]
63+ getStr : Eff String [STDIO]
64+ getChar : Eff Char [STDIO]
66+ Handler StdIO IO where { ... }
67+ Handler StdIO (IOExcept a) where { ... }
72+A program which reads the user’s name, then says hello, can be written
77+ hello : Eff () [STDIO]
78+ hello = do putStr "Name? "
80+ putStrLn ("Hello " ++ trim x ++ "!")
82+We use ``trim`` here to remove the trailing newline from the
83+input. The resource associated with ``STDIO`` is simply the empty
84+tuple, which has a default value ``()``, so we can run this as
92+In ``hello`` we could also use ``!``-notation instead of ``x <-
93+getStr``, since we only use the string that is read once:
97+ hello : Eff () [STDIO]
98+ hello = do putStr "Name? "
99+ putStrLn ("Hello " ++ trim !getStr ++ "!")
101+More interestingly, we can combine multiple effects in one
102+program. For example, we can loop, counting the number of people we’ve
105+.. code-block:: idris
107+ hello : Eff () [STATE Int, STDIO]
108+ hello = do putStr "Name? "
109+ putStrLn ("Hello " ++ trim !getStr ++ "!")
111+ putStrLn ("I've said hello to: " ++ show !get ++ " people")
114+The list of effects given in ``hello`` means that the function can
115+call ``get`` and ``put`` on an integer state, and any functions which
116+read and write from the console. To run this, ``main`` does not need
119+Aside: Resource Types
120+---------------------
122+To find out the resource type of an effect, if necessary (for example
123+if we want to initialise a resource explicitly with ``runInit`` rather
124+than using a default value with ``run``) we can run the
125+``resourceType`` function at the REPL:
127+.. code-block:: idris
129+ *ConsoleIO> resourceType STDIO
131+ *ConsoleIO> resourceType (STATE Int)
138+effect is declared in module ``Effect.Exception``. This allows programs
139+to exit immediately with an error, or errors to be handled more
143+.. code-block:: idris
145+ module Effect.Exception
147+ EXCEPTION : Type -> EFFECT
149+ raise : a -> Eff b [EXCEPTION a]
151+ Handler (Exception a) Maybe where { ... }
152+ Handler (Exception a) List where { ... }
153+ Handler (Exception a) (Either a) where { ... }
154+ Handler (Exception a) (IOExcept a) where { ... }
155+ Show a => Handler (Exception a) IO where { ... }
160+Suppose we have a ``String`` which is expected to represent an integer
161+in the range ``0`` to ``n``. We can write a function ``parseNumber``
162+which returns an ``Int`` if parsing the string returns a number in the
163+appropriate range, or throws an exception otherwise. Exceptions are
164+parameterised by an error type:
166+.. code-block:: idris
168+ data Error = NotANumber | OutOfRange
170+ parseNumber : Int -> String -> Eff Int [EXCEPTION Error]
172+ = if all isDigit (unpack str)
173+ then let x = cast str in
174+ if (x >=0 && x <= num)
176+ else raise OutOfRange
177+ else raise NotANumber
179+Programs which support the ``EXCEPTION`` effect can be run in any
180+context which has some way of throwing errors, for example, we can run
181+``parseNumber`` in the ``Either Error`` context. It returns a value of
182+the form ``Right x`` if successful:
184+.. code-block:: idris
186+ *Exception> the (Either Error Int) $ run (parseNumber 42 "20")
187+ Right 20 : Either Error Int
189+Or ``Left e`` on failure, carrying the appropriate exception:
191+.. code-block:: idris
193+ *Exception> the (Either Error Int) $ run (parseNumber 42 "50")
194+ Left OutOfRange : Either Error Int
196+ *Exception> the (Either Error Int) $ run (parseNumber 42 "twenty")
197+ Left NotANumber : Either Error Int
199+In fact, we can do a little bit better with ``parseNumber``, and have
200+it return a *proof* that the integer is in the required range along
201+with the integer itself. One way to do this is define a type of
202+bounded integers, ``Bounded``:
204+.. code-block:: idris
206+ Bounded : Int -> Type
207+ Bounded x = (n : Int ** So (n >= 0 && n <= x))
209+Recall that ``So`` is parameterised by a ``Bool``, and only ``So
210+True`` is inhabited. We can use ``choose`` to construct such a value
211+from the result of a dynamic check:
213+.. code-block:: idris
215+ data So : Bool -> Type where
218+ choose : (b : Bool) -> Either (So b) (So (not b))
220+We then write ``parseNumber`` using ``choose`` rather than an
221+``if/then/else`` construct, passing the proof it returns on success as
222+the boundedness proof:
224+.. code-block:: idris
226+ parseNumber : (x : Int) -> String -> Eff (Bounded x) [EXCEPTION Error]
228+ = if all isDigit (unpack str)
229+ then let num = cast str in
230+ case choose (num >=0 && num <= x) of
231+ Left p => pure (num ** p)
232+ Right p => raise OutOfRange
233+ else raise NotANumber
238+Random number generation is also implemented by the library, in module
241+.. code-block:: idris
243+ module Effect.Random
247+ srand : Integer -> Eff () [RND]
248+ rndInt : Integer -> Integer -> Eff Integer [RND]
249+ rndFin : (k : Nat) -> Eff (Fin (S k)) [RND]
251+ Handler Random m where { ... }
253+Random number generation is considered side-effecting because its
254+implementation generally relies on some external source of randomness.
255+The default implementation here relies on an integer *seed*, which can
256+be set with ``srand``. A specific seed will lead to a predictable,
257+repeatable sequence of random numbers. There are two functions which
258+produce a random number:
260+- ``rndInt``, which returns a random integer between the given lower
263+- ``rndFin``, which returns a random element of a finite set
264+ (essentially a number with an upper bound given in its type).
269+We can use the ``RND`` effect to implement a simple guessing game. The
270+``guess`` function, given a target number, will repeatedly ask the
271+user for a guess, and state whether the guess is too high, too low, or
274+.. code-block:: idris
276+ guess : Int -> Eff () [STDIO]
278+For reference, the code for ``guess`` is given below:
281+.. code-block:: idris
283+ guess : Int -> Eff () [STDIO]
285+ = do putStr "Guess: "
286+ case run {m=Maybe} (parseNumber 100 (trim !getStr)) of
287+ Nothing => do putStrLn "Invalid input"
290+ case compare v target of
291+ LT => do putStrLn "Too low"
293+ EQ => putStrLn "You win!"
294+ GT => do putStrLn "Too high"
297+Note that we use ``parseNumber`` as defined previously to read user input, but
298+we don’t need to list the ``EXCEPTION`` effect because we use a nested ``run``
299+to invoke ``parseNumber``, independently of the calling effectful program.
301+To invoke this, we pick a random number within the range 0–100,
302+having set up the random number generator with a seed, then run
305+.. code-block:: idris
307+ game : Eff () [RND, STDIO]
308+ game = do srand 123456789
309+ guess (fromInteger !(rndInt 0 100))
314+If no seed is given, it is set to the ``default`` value. For a less
315+predictable game, some better source of randomness would be required,
316+for example taking an initial seed from the system time. To see how to
317+do this, see the ``SYSTEM`` effect described in :ref:`sect-appendix`.
323+The listing below gives the definition of the non-determinism
324+effect, which allows a program to choose a value non-deterministically
325+from a list of possibilities in such a way that the entire computation
328+.. code-block:: idris
331+ import Effect.Select
335+ select : List a -> Eff a [SELECT]
337+ Handler Selection Maybe where { ... }
338+ Handler Selection List where { ... }
343+The ``SELECT`` effect can be used to solve constraint problems, such
344+as finding Pythagorean triples. The idea is to use ``select`` to give
345+a set of candidate values, then throw an exception for any combination
346+of values which does not satisfy the constraint:
348+.. code-block:: idris
350+ triple : Int -> Eff (Int, Int, Int) [SELECT, EXCEPTION String]
351+ triple max = do z <- select [1..max]
354+ if (x * x + y * y == z * z)
356+ else raise "No triple"
358+This program chooses a value for ``z`` between ``1`` and ``max``, then
359+values for ``y`` and ``x``. In operation, after a ``select``, the
360+program executes the rest of the ``do``-block for every possible
361+assignment, effectively searching depth-first. If the list is empty
362+(or an exception is thrown) execution fails.
364+There are handlers defined for ``Maybe`` and ``List`` contexts, i.e.
365+contexts which can capture failure. Depending on the context ``m``,
366+``triple`` will either return the first triple it finds (if in
367+``Maybe`` context) or all triples in the range (if in ``List``
368+context). We can try this as follows:
370+.. code-block:: idris
373+ main = do print $ the (Maybe _) $ run (triple 100)
374+ print $ the (List _) $ run (triple 100)
379+We now return to the ``vadd`` program from the introduction. Recall the
382+.. code-block:: idris
384+ vadd : Vect n Int -> Vect n Int -> Vect n Int
386+ vadd (x :: xs) (y :: ys) = x + y :: vadd xs ys
388+Using , we can set up a program so that it reads input from a user,
389+checks that the input is valid (i.e both vectors contain integers, and
390+are the same length) and if so, pass it on to ``vadd``. First, we
391+write a wrapper for ``vadd`` which checks the lengths and throw an
392+exception if they are not equal. We can do this for input vectors of
393+length ``n`` and ``m`` by matching on the implicit arguments ``n`` and
394+``m`` and using ``decEq`` to produce a proof of their equality, if
397+.. code-block:: idris
399+ vadd_check : Vect n Int -> Vect m Int ->
400+ Eff (Vect m Int) [EXCEPTION String]
401+ vadd_check {n} {m} xs ys with (decEq n m)
402+ vadd_check {n} {m=n} xs ys | (Yes Refl) = pure (vadd xs ys)
403+ vadd_check {n} {m} xs ys | (No contra) = raise "Length mismatch"
405+To read a vector from the console, we implement a function of the
408+.. code-block:: idris
410+ read_vec : Eff (p ** Vect p Int) [STDIO]
412+This returns a dependent pair of a length, and a vector of that
413+length, because we cannot know in advance how many integers the user
414+is going to input. We can use ``-1`` to indicate the end of input:
416+.. code-block:: idris
418+ read_vec : Eff (p ** Vect p Int) [STDIO]
419+ read_vec = do putStr "Number (-1 when done): "
420+ case run (parseNumber (trim !getStr)) of
421+ Nothing => do putStrLn "Input error"
423+ Just v => if (v /= -1)
424+ then do (_ ** xs) <- read_vec
428+ parseNumber : String -> Eff Int [EXCEPTION String]
430+ = if all (\x => isDigit x || x == '-') (unpack str)
431+ then pure (cast str)
432+ else raise "Not a number"
434+This uses a variation on ``parseNumber`` which does not require a
435+number to be within range.
437+Finally, we write a program which reads two vectors and prints the
438+result of pairwise addition of them, throwing an exception if the
439+inputs are of differing lengths:
441+.. code-block:: idris
443+ do_vadd : Eff () [STDIO, EXCEPTION String]
444+ do_vadd = do putStrLn "Vector 1"
445+ (_ ** xs) <- read_vec
447+ (_ ** ys) <- read_vec
448+ putStrLn (show !(vadd_check xs ys))
450+By having explicit lengths in the type, we can be sure that ``vadd``
451+is only being used where the lengths of inputs are guaranteed to be
452+equal. This does not stop us reading vectors from user input, but it
453+does require that the lengths are checked and any discrepancy is dealt
457+Example: An Expression Calculator
458+=================================
460+To show how these effects can fit together, let us consider an
461+evaluator for a simple expression language, with addition and integer
464+.. code-block:: idris
466+ data Expr = Val Integer
469+An evaluator for this language always returns an ``Integer``, and
470+there are no situations in which it can fail!
472+.. code-block:: idris
474+ eval : Expr -> Integer
476+ eval (Add l r) = eval l + eval r
478+If we add variables, however, things get more interesting. The
479+evaluator will need to be able to access the values stored in
480+variables, and variables may be undefined.
482+.. code-block:: idris
484+ data Expr = Val Integer
488+To start, we will change the type of ``eval`` so that it is effectful,
489+and supports an exception effect for throwing errors, and a state
490+containing a mapping from variable names (as ``String``) to their
493+.. code-block:: idris
496+ Env = List (String, Integer)
498+ eval : Expr -> Eff Integer [EXCEPTION String, STATE Env]
499+ eval (Val x) = pure x
500+ eval (Add l r) = pure $ !(eval l) + !(eval r)
502+Note that we are using ``!``-notation to avoid having to bind
503+subexpressions in a ``do`` block. Next, we add a case for evaluating
506+.. code-block:: idris
508+ eval (Var x) = case lookup x !get of
509+ Nothing => raise $ "No such variable " ++ x
510+ Just val => pure val
512+This retrieves the state (with ``get``, supported by the ``STATE Env``
513+effect) and raises an exception if the variable is not in the
514+environment (with ``raise``, supported by the ``EXCEPTION String``
517+To run the evaluator on a particular expression in a particular
518+environment of names and their values, we can write a function which
519+sets the state then invokes ``eval``:
521+.. code-block:: idris
523+ runEval : List (String, Integer) -> Expr -> Maybe Integer
524+ runEval args expr = run (eval' expr)
525+ where eval' : Expr -> Eff Integer [EXCEPTION String, STATE Env]
526+ eval' e = do put args
529+We have picked ``Maybe`` as a computation context here; it needs to be
530+a context which is available for every effect supported by
531+``eval``. In particular, because we have exceptions, it needs to be a
532+context which supports exceptions. Alternatively, ``Either String`` or
533+``IO`` would be fine, for example.
535+What if we want to extend the evaluator further, with random number
536+generation? To achieve this, we add a new constructor to ``Expr``,
537+which gives a random number up to a maximum value:
539+.. code-block:: idris
541+ data Expr = Val Integer
546+Then, we need to deal with the new case, making sure that we extend
547+the list of events to include ``RND``. It doesn't matter where ``RND``
548+appears in the list, as long as it is present:
550+.. code-block:: idris
552+ eval : Expr -> Eff Integer [EXCEPTION String, RND, STATE Env]
554+ eval (Random upper) = rndInt 0 upper
556+For test purposes, we might also want to print the random number which
559+.. code-block:: idris
561+ eval (Random upper) = do val <- rndInt 0 upper
565+If we try this without extending the effects list, we would see an
566+error something like the following:
570+ Expr.idr:28:6:When elaborating right hand side of eval:
573+ [(EXCEPTION String), RND, (STATE (List (String, Integer)))]
575+In other words, the ``STDIO`` effect is not available. We can correct
576+this simply by updating the type of ``eval`` to include ``STDIO``.
578+.. code-block:: idris
580+ eval : Expr -> Eff Integer [STDIO, EXCEPTION String, RND, STATE Env]
582+.. note:: Using ``STDIO`` will restrict the number of contexts in
583+ which ``eval`` can be ``run`` to those which support
584+ ``STDIO``, such as ``IO``. Once effect lists get longer, it
585+ can be a good idea instead to encapsulate sets of effects in
586+ a type synonym. This is achieved as follows, simply by
587+ defining a function which computes a type, since types are
588+ first class in Idris:
590+ .. code-block:: idris
592+ EvalEff : Type -> Type
593+ EvalEff t = Eff t [STDIO, EXCEPTION String, RND, STATE Env]
595+ eval : Expr -> EvalEff Integer
docs/effects/state.rstnew file+529
@@ -0,0 +1,529 @@
7+Many programs, even pure programs, can benefit from locally mutable
8+state. For example, consider a program which tags binary tree nodes
9+with a counter, by an inorder traversal (i.e. counting depth first,
10+left to right). This would perform something like the following:
14+We can describe binary trees with the following data type ``BTree``
15+and ``testTree`` to represent the example input above:
20+ | Node (BTree a) a (BTree a)
22+ testTree : BTree String
23+ testTree = Node (Node Leaf "Jim" Leaf)
25+ (Node (Node Leaf "Alice" Leaf)
27+ (Node Leaf "Bob" Leaf))
29+Then our function to implement tagging, beginning to tag with a
30+specific value ``i``, has the following type:
34+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)
39+Naïvely, we can implement ``treeTag`` by implementing a helper
40+function which propagates a counter, returning the result of the count
45+ treeTagAux : (i : Int) -> BTree a -> (Int, BTree (Int, a))
46+ treeTagAux i Leaf = (i, Leaf)
47+ treeTagAux i (Node l x r)
48+ = let (i', l') = treeTagAux i l in
50+ let (i'', r') = treeTagAux (i' + 1) r in
53+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)
54+ treeTag i x = snd (treeTagAux i x)
56+This gives the expected result when run at the REPL prompt:
60+ *TreeTag> treeTag 1 testTree
61+ Node (Node Leaf (1, "Jim") Leaf)
63+ (Node (Node Leaf (3, "Alice") Leaf)
65+ (Node Leaf (5, "Bob") Leaf)) : BTree (Int, String)
67+This works as required, but there are several problems when we try to
68+scale this to larger programs. It is error prone, because we need to
69+ensure that state is propagated correctly to the recursive calls (i.e.
70+passing the appropriate ``i`` or ``i’``). It is hard to read, because
71+the functional details are obscured by the state propagation. Perhaps
72+most importantly, there is a common programming pattern here which
73+should be abstracted but instead has been implemented by hand. There
74+is local mutable state (the counter) which we have had to make
77+Introducing ``Effects``
78+=======================
80+Idris provides a library, ``Effects`` [3]_, which captures this
81+pattern and many others involving effectful computation [1]_. An
82+effectful program ``f`` has a type of the following form:
86+ f : (x1 : a1) -> (x2 : a2) -> ... -> Eff t effs
88+That is, the return type gives the effects that ``f`` supports
89+(``effs``, of type ``List EFFECT``) and the type the computation
90+returns ``t``. So, our ``treeTagAux`` helper could be written with the
95+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE Int]
97+That is, ``treeTagAux`` has access to an integer state, because the
98+list of available effects includes ``STATE Int``. ``STATE`` is
99+declared as follows in the module ``Effect.State`` (that is, we must
100+``import Effect.State`` to be able to use it):
102+.. code-block:: idris
104+ STATE : Type -> EFFECT
106+It is an effect parameterised by a type (by convention, we write
107+effects in all capitals). The ``treeTagAux`` function is an effectful
108+program which builds a new tree tagged with ``Ints``, and is
109+implemented as follows:
111+.. code-block:: idris
113+ treeTagAux Leaf = pure Leaf
114+ treeTagAux (Node l x r)
115+ = do l' <- treeTagAux l
119+ pure (Node l' (i, x) r')
121+There are several remarks to be made about this implementation.
122+Essentially, it hides the state, which can be accessed using ``get``
123+and updated using ``put``, but it introduces several new features.
124+Specifically, it uses ``do``-notation, binding variables with ``<-``,
125+and a ``pure`` function. There is much to be said about these
126+features, but for our purposes, it suffices to know the following:
128+- ``do`` blocks allow effectful operations to be sequenced.
130+- ``x <- e`` binds the result of an effectful operation ``e`` to a
131+ variable ``x``. For example, in the above code, ``treeTagAux l`` is
132+ an effectful operation returning ``BTree (Int, a)``, so ``l’`` has
133+ type ``BTree (Int, a)``.
135+- ``pure e`` turns a pure value ``e`` into the result of an effectful
138+The ``get`` and ``put`` functions read and write a state ``t``,
139+assuming that the ``STATE t`` effect is available. They have the
140+following types, polymorphic in the state ``t`` they manage:
142+.. code-block:: idris
144+ get : Eff t [STATE t]
145+ put : t -> Eff () [STATE t]
147+A program in ``Eff`` can call any other function in ``Eff`` provided
148+that the calling function supports at least the effects required by
149+the called function. In this case, it is valid for ``treeTagAux`` to
150+call both ``get`` and ``put`` because all three functions support the
151+``STATE Int`` effect.
153+Programs in ``Eff`` are run in some underlying *computation context*,
154+using the ``run`` or ``runPure`` function. Using ``runPure``, which
155+runs an effectful program in the identity context, we can write the
156+``treeTag`` function as follows, using ``put`` to initialise the
159+.. code-block:: idris
161+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)
162+ treeTag i x = runPure (do put i
165+We could also run the program in an impure context such as ``IO``,
166+without changing the definition of ``treeTagAux``, by using ``run``
167+instead of ``runPure``:
169+.. code-block:: idris
171+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE Int]
174+ treeTag : (i : Int) -> BTree a -> IO (BTree (Int, a))
175+ treeTag i x = run (do put i
178+Note that the definition of ``treeTagAux`` is exactly as before. For
179+reference, this complete program (including a ``main`` to run it) is
180+shown in Listing [introprog].
182+.. code-block:: idris
190+ | Node (BTree a) a (BTree a)
192+ Show a => Show (BTree a) where
194+ show (Node l x r) = "[" ++ show l ++ " "
198+ testTree : BTree String
199+ testTree = Node (Node Leaf "Jim" Leaf)
201+ (Node (Node Leaf "Alice" Leaf)
203+ (Node Leaf "Bob" Leaf))
205+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE Int]
206+ treeTagAux Leaf = pure Leaf
207+ treeTagAux (Node l x r) = do l' <- treeTagAux l
211+ pure (Node l' (i, x) r')
213+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)
214+ treeTag i x = runPure (do put i; treeTagAux x)
217+ main = print (treeTag 1 testTree)
219+Effects and Resources
220+=====================
222+Each effect is associated with a *resource*, which is initialised
223+before an effectful program can be run. For example, in the case of
224+``STATE Int`` the corresponding resource is the integer state itself.
225+The types of ``runPure`` and ``run`` show this (slightly simplified
226+here for illustrative purposes):
228+.. code-block:: idris
230+ runPure : {env : Env id xs} -> Eff a xs -> a
231+ run : Applicative m => {env : Env m xs} -> Eff a xs -> m a
233+The ``env`` argument is implicit, and initialised automatically where
234+possible using default values given by implementations of the following
237+.. code-block:: idris
239+ interface Default a where
242+Implementations of ``Default`` are defined for all primitive types, and many
243+library types such as ``List``, ``Vect``, ``Maybe``, pairs, etc.
244+However, where no default value exists for a resource type (for
245+example, you may want a ``STATE`` type for which there is no
246+``Default`` implementation) the resource environment can be given explicitly
247+using one of the following functions:
249+.. code-block:: idris
251+ runPureInit : Env id xs -> Eff a xs -> a
252+ runInit : Applicative m => Env m xs -> Eff a xs -> m a
254+To be well-typed, the environment must contain resources corresponding
255+exactly to the effects in ``xs``. For example, we could also have
256+implemented ``treeTag`` by initialising the state as follows:
258+.. code-block:: idris
260+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)
261+ treeTag i x = runPureInit [i] (treeTagAux x)
266+What if we have more than one state, especially more than one state of
267+the same type? How would ``get`` and ``put`` know which state they
268+should be referring to? For example, how could we extend the tree
269+tagging example such that it additionally counts the number of leaves
270+in the tree? One possibility would be to change the state so that it
271+captured both of these values, e.g.:
273+.. code-block:: idris
275+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE (Int, Int)]
277+Doing this, however, ties the two states together throughout (as well
278+as not indicating which integer is which). It would be nice to be able
279+to call effectful programs which guaranteed only to access one of the
280+states, for example. In a larger application, this becomes
281+particularly important.
283+The library therefore allows effects in general to be *labelled* so
284+that they can be referred to explicitly by a particular name. This
285+allows multiple effects of the same type to be included. We can count
286+leaves and update the tag separately, by labelling them as follows:
288+.. code-block:: idris
290+ treeTagAux : BTree a -> Eff (BTree (Int, a))
291+ ['Tag ::: STATE Int,
292+ 'Leaves ::: STATE Int]
294+The ``:::`` operator allows an arbitrary label to be given to an
295+effect. This label can be any type—it is simply used to identify an
296+effect uniquely. Here, we have used a symbol type. In general
297+``’name`` introduces a new symbol, the only purpose of which is to
298+disambiguate values [2]_.
300+When an effect is labelled, its operations are also labelled using the
301+``:-`` operator. In this way, we can say explicitly which state we
302+mean when using ``get`` and ``put``. The tree tagging program which
303+also counts leaves can be written as follows:
305+.. code-block:: idris
307+ treeTagAux Leaf = do
308+ 'Leaves :- update (+1)
310+ treeTagAux (Node l x r) = do
315+ pure (Node l' (i, x) r')
317+The ``update`` function here is a combination of ``get`` and ``put``,
318+applying a function to the current state.
320+.. code-block:: idris
322+ update : (x -> x) -> Eff () [STATE x]
324+Finally, our top level ``treeTag`` function now returns a pair of the
325+number of leaves, and the new tree. Resources for labelled effects are
326+initialised using the ``:=`` operator (reminiscent of assignment in an
327+imperative language):
329+.. code-block:: idris
331+ treeTag : (i : Int) -> BTree a -> (Int, BTree (Int, a))
332+ treeTag i x = runPureInit ['Tag := i, 'Leaves := 0]
333+ (do x' <- treeTagAux x
334+ leaves <- 'Leaves :- get
337+To summarise, we have:
339+- ``:::`` to convert an effect to a labelled effect.
341+- ``:-`` to convert an effectful operation to a labelled effectful operation.
343+- ``:=`` to initialise a resource for a labelled effect.
345+Or, more formally with their types (slightly simplified to account
346+only for the situation where available effects are not updated):
348+.. code-block:: idris
350+ (:::) : lbl -> EFFECT -> EFFECT
351+ (:-) : (l : lbl) -> Eff a [x] -> Eff a [l ::: x]
352+ (:=) : (l : lbl) -> res -> LRes l res
354+Here, ``LRes`` is simply the resource type associated with a labelled
355+effect. Note that labels are polymorphic in the label type ``lbl``.
356+Hence, a label can be anything—a string, an integer, a type, etc.
361+In many cases, using ``do``-notation can make programs unnecessarily
362+verbose, particularly in cases where the value bound is used once,
363+immediately. The following program returns the length of the
364+``String`` stored in the state, for example:
366+.. code-block:: idris
368+ stateLength : Eff Nat [STATE String]
369+ stateLength = do x <- get
372+This seems unnecessarily verbose, and it would be nice to program in a
373+more direct style in these cases. provides ``!``-notation to help with
374+this. The above program can be written instead as:
376+.. code-block:: idris
378+ stateLength : Eff Nat [STATE String]
379+ stateLength = pure (length !get)
381+The notation ``!expr`` means that the expression ``expr`` should be
382+evaluated and then implicitly bound. Conceptually, we can think of
383+``!`` as being a prefix function with the following type:
385+.. code-block:: idris
389+Note, however, that it is not really a function, merely syntax! In
390+practice, a subexpression ``!expr`` will lift ``expr`` as high as
391+possible within its current scope, bind it to a fresh name ``x``, and
392+replace ``!expr`` with ``x``. Expressions are lifted depth first, left
393+to right. In practice, ``!``-notation allows us to program in a more
394+direct style, while still giving a notational clue as to which
395+expressions are effectful.
397+For example, the expression:
399+.. code-block:: idris
401+ let y = 42 in f !(g !(print y) !x)
405+.. code-block:: idris
407+ let y = 42 in do y' <- print y
415+Underneath, ``Eff`` is an overloaded function which translates to an
416+underlying type ``EffM``:
418+.. code-block:: idris
420+ EffM : (m : Type -> Type) -> (t : Type)
422+ -> (t -> List EFFECT) -> Type
424+This is more general than the types we have been writing so far. It is
425+parameterised over an underlying computation context ``m``, a
426+result type ``t`` as we have already seen, as well as a ``List EFFECT`` and a
427+function type ``t -> List EFFECT``.
429+These additional parameters are the list of *input* effects, and a
430+list of *output* effects, computed from the result of an effectful
431+operation. That is: running an effectful program can change the set
432+of effects available! This is a particularly powerful idea, and we
433+will see its consequences in more detail later. Some examples of
434+operations which can change the set of available effects are:
436+- Updating a state containing a dependent type (for example adding an element to a vector).
438+- Opening a file for reading is an effect, but whether the file really
439+ *is* open afterwards depends on whether the file was successfully
442+- Closing a file means that reading from the file should no longer be
445+While powerful, this can make uses of the ``EffM`` type hard to read.
446+Therefore the library provides an overloaded function ``Eff``
447+There are the following three versions:
449+.. code-block:: idris
451+ SimpleEff.Eff : (t : Type) -> (input_effs : List EFFECT) -> Type
452+ TransEff.Eff : (t : Type) -> (input_effs : List EFFECT) ->
453+ (output_effs : List EFFECT) -> Type
454+ DepEff.Eff : (t : Type) -> (input_effs : List EFFECT) ->
455+ (output_effs_fn : t -> List EFFECT) -> Type
457+So far, we have used only the first version, ``SimpleEff.Eff``, which
458+is defined as follows:
460+.. code-block:: idris
462+ Eff : (x : Type) -> (es : List EFFECT) -> Type
463+ Eff x es = {m : Type -> Type} -> EffM m x es (\v => es)
465+i.e. the set of effects remains the same on output. This suffices for
466+the ``STATE`` example we have seen so far, and for many useful
467+side-effecting programs. We could also have written ``treeTagAux``
468+with the expanded type:
470+.. code-block:: idris
472+ treeTagAux : BTree a ->
473+ EffM m (BTree (Int, a)) [STATE Int] (\x => [STATE Int])
475+Later, we will see programs which update effects:
477+.. code-block:: idris
483+.. code-block:: idris
485+ EffM m a xs (\_ => xs')
487+i.e. the set of effects is updated to ``xs’`` (think of a transition
488+in a state machine). There is, for example, a version of ``put`` which
489+updates the type of the state:
491+.. code-block:: idris
493+ putM : y -> Eff () [STATE x] [STATE y]
497+.. code-block:: idris
499+ Eff t xs (\res => xs')
503+.. code-block:: idris
505+ EffM m t xs (\res => xs')
507+i.e. the set of effects is updated according to the result of the
508+operation ``res``, of type ``t``.
510+Parameterising ``EffM`` over an underlying computation context allows us
511+to write effectful programs which are specific to one context, and in some
512+cases to write programs which *extend* the list of effects available using
513+the ``new`` function, though this is beyond the scope of this tutorial.
515+.. [1] The earlier paper [3]_ describes the essential implementation
516+ details, although the library presented there is an earlier version
517+ which is less powerful than that presented in this tutorial.
519+.. [2] In practice, ``’name`` simply introduces a new empty type
521+.. [3] Edwin Brady. 2013. Programming and reasoning with algebraic
522+ effects and dependent types. SIGPLAN Not. 48, 9 (September
523+ 2013), 133-144. DOI=10.1145/2544174.2500581
524+ http://dl.acm.org/citation.cfm?doid=2544174.2500581
528+.. |image| image:: ../image/effects-tree.png
docs/effects/summary.rstnew file+152
@@ -0,0 +1,152 @@
7+This appendix gives interfaces for the core effects provided by the
15+ module Effect.Exception
19+ import Control.IOExcept
21+ EXCEPTION : Type -> EFFECT
23+ raise : a -> Eff b [EXCEPTION a]
25+ Handler (Exception a) Maybe where { ... }
26+ Handler (Exception a) List where { ... }
27+ Handler (Exception a) (Either a) where { ... }
28+ Handler (Exception a) (IOExcept a) where { ... }
29+ Show a => Handler (Exception a) IO where { ... }
39+ import Control.IOExcept
41+ FILE_IO : Type -> EFFECT
43+ data OpenFile : Mode -> Type
45+ open : (fname : String)
47+ -> Eff Bool [FILE_IO ()]
48+ (\res => [FILE_IO (case res of
51+ close : Eff () [FILE_IO (OpenFile m)] [FILE_IO ()]
53+ readLine : Eff String [FILE_IO (OpenFile Read)]
54+ writeLine : String -> Eff () [FILE_IO (OpenFile Write)]
55+ eof : Eff Bool [FILE_IO (OpenFile Read)]
57+ Handler FileIO IO where { ... }
72+ srand : Integer -> Eff () [RND]
73+ rndInt : Integer -> Integer -> Eff Integer [RND]
74+ rndFin : (k : Nat) -> Eff (Fin (S k)) [RND]
76+ Handler Random m where { ... }
89+ select : List a -> Eff a [SELECT]
91+ Handler Selection Maybe where { ... }
92+ Handler Selection List where { ... }
103+ STATE : Type -> EFFECT
105+ get : Eff x [STATE x]
106+ put : x -> Eff () [STATE x]
107+ putM : y -> Eff () [STATE x] [STATE y]
108+ update : (x -> x) -> Eff () [STATE x]
110+ Handler State m where { ... }
115+.. code-block:: idris
120+ import Control.IOExcept
124+ putChar : Char -> Eff () [STDIO]
125+ putStr : String -> Eff () [STDIO]
126+ putStrLn : String -> Eff () [STDIO]
128+ getStr : Eff String [STDIO]
129+ getChar : Eff Char [STDIO]
131+ Handler StdIO IO where { ... }
132+ Handler StdIO (IOExcept a) where { ... }
137+.. code-block:: idris
139+ module Effect.System
143+ import Control.IOExcept
147+ getArgs : Eff (List String) [SYSTEM]
148+ time : Eff Int [SYSTEM]
149+ getEnv : String -> Eff (Maybe String) [SYSTEM]
151+ Handler System IO where { ... }
152+ Handler System (IOExcept a) where { ... }
docs/elaboratorReflection/elabReflection.rstnew file+60
@@ -0,0 +1,60 @@
1+Extending Idris using Elaborator Reflection
2+===========================================
4+Idris provides a mechanism to modify the language without having to recompile Idris itself. We can think of this in terms of metaprogramming or domain specific languages or just building in new capabilities.
6+In order to extend the language we need to know something about how Idris is compiled. This page explains only what is needed to customise the elaboration. For more information about the compiler's implementation see `Edwin Brady's 2013 paper`_ and for customising the elaboration process see `Elaborator reflection: extending Idris in Idris`_ and `David Christiansen's PhD thesis`_.
8+Compilation of Idris proceeds through a number of stages.
10+- First, Idris is desugared by inserting placeholders for terms to be guessed by the compiler and replacing certain syntactic forms, such as do-notation, with the functions that implement them.
11+- Then, this desugared Idris is translated into a much simpler core language, called TT. This translation process is called elaboration.
12+- Finally, TT is type checked a second time to rule out errors, and then compiled into the target language.
14+.. image:: ../image/idrisTopLevel.png
17+ :alt: diagram illustrating these stages of Idris compilation
19+TT is a core language which is syntactically very simple. This makes it easy for computers to process but very verbose and hard for humans to read. The Idris elaborator is written in Haskell using an elaboration library that was inspired by the tactics in interactive proof assistants such as Coq.
23+ * - There are some similarities with a proof assistant but in Idris the elaborator is an interpreter of Idris source in the elaboration monad, where each syntactic construct of Idris is interpreted as a sequence of tactics.
24+ - .. image:: ../image/compareToProofAssist.png
27+ :alt: diagram comparing elaboration with proof assistant
29+The primitives in the elaboration library are not just useful for the implementors of Idris itself. They can also be used by authors of extensions to the compiler, using a mechanism known as elaborator reflection.
30+During elaboration TT (Raw) structure contains:
32+- holes - placeholders for terms that have not yet been filled in.
33+- guesses - similar to let bindings, except with no reduction rule, so that elaboration programs can control the precise shape of terms that are under construction.
35+For more information about holes and guesses see `Dependently Typed Functional Programs and their Proofs by McBride 1999`_.
37+The following diagram is intended to illustrate a high level view of the tactics and how this eventually results in the TT language being generated. It is not necessary to understand the details at this stage. The intention is to help build up some intuition so that, when we get into the details, we can recognise how this fits into the big picture.
39+.. image:: ../image/elabOverview.png
42+ :alt: diagram illustrating overview of TT language being generated from tactics.
44+As already mentioned the TT core language is kept syntactically very simple, for instance, here are the binders in TT with corresponding code and logic type validity rules:
48+ * - This diagram illustrates the basis of the compilation process in logic (in this case for binders). It is not necessary to be an expert logician to understand elaborator reflection. However, when learning about tactics, they may appear arbitrary without knowing some theory. For more information about this see `Edwin Brady's 2013 paper`_.
49+ - .. image:: ../image/binders.png
52+ :alt: diagram illustrating basis of code in logic
55+.. _`Edwin Brady's 2013 paper`: https://eb.host.cs.st-andrews.ac.uk/drafts/impldtp.pdf
56+.. _`Elaborator reflection: extending Idris in Idris`: https://dl.acm.org/citation.cfm?doid=2951913.2951932
57+.. _`David Christiansen's PhD thesis`: https://davidchristiansen.dk/david-christiansen-phd.pdf
58+.. _`Dependently Typed Functional Programs and their Proofs by McBride 1999`: https://www.era.lib.ed.ac.uk/handle/1842/374
docs/elaboratorReflection/elaborator-reflection.rstnew file+209
@@ -0,0 +1,209 @@
1+.. _elaborator-reflection:
3+**********************************
4+Elaborator Reflection Introduction
5+**********************************
7+The Idris elaborator is responsible for converting high-level Idris code into the core language.
8+It is implemented as a kind of embedded tactic language in Haskell, where tactic scripts are written in an *elaboration monad* that provides error handling and a proof state.
9+For details, see `Edwin Brady's 2013 paper in the Journal of Functional
10+Programming <https://eb.host.cs.st-andrews.ac.uk/drafts/impldtp.pdf>`_.
12+Elaborator reflection makes the elaboration type as well as a selection of its tactics available to Idris code.
13+This means that metaprograms written in Idris can have complete control over the elaboration process, generating arbitrary code, and they have access to all of the facilities available in the elaborator, such as higher-order unification, type checking, and emitting auxiliary definitions.
18+The elaborator state contains information about the ongoing elaboration process.
19+In particular, it contains a *goal type*, which is to be filled by an under-construction *proof term*.
20+The proof term can contain *holes*, each of which has a scope in which it is valid and a type.
21+Some holes may additionally contain *guesses*, which can be substituted in the scope of the hole.
22+The holes are tracked in a *hole queue*, and one of them is *focused*.
23+In addition to the goal type, proof term, and holes, the elaborator state contains a collection of unsolved unification problems that can affect elaboration.
25+The elaborator state is not directly available to Idris programs.
26+Instead, it is modified through the use of *tactics*, which are operations that affect the elaborator state.
27+A tactic that returns a value of type ``a``, potentially modifying the elaborator state, has type ``Elab a``.
28+The default tactics are all in the namespace ``Language.Reflection.Elab.Tactics``.
31+Running Elaborator Scripts
32+==========================
34+On their own, tactics have no effect.
35+The meta-operation ``%runElab script`` runs ``script`` in the current elaboration context.
36+Before you can use ``%runElab``, you will have to enable the language extension by adding
37+``%language ElabReflection`` in your file (or by passing ``-X ElabReflection`` to the
38+``idris`` executable from your command line).
39+For example, the following script constructs the identity function at type ``Nat``:
44+ idNat = %runElab (do intro `{{x}}
49+On the right-hand side, the Idris elaborator has the goal ``Nat -> Nat``.
50+When it encounters the ``%runElab`` directive, it fulfills this goal by running the provided script.
51+The first tactic, ``intro``, constructs a lambda that binds the name ``x``.
52+The name argument is optional because a default name can be taken from the function type.
53+Now, the proof term is of the form ``\x : Nat => {hole}``.
54+The second tactic, ``fill``, fills this hole with a guess, giving the term ``\x : Nat => {hole≈x}``.
55+Finally, the ``solve`` tactic instantiates the guess, giving the result ``\x : Nat => x``.
57+Because elaborator scripts are ordinary Idris expressions, it is also possible to use them in multiple contexts.
58+Note that there is nothing ``Nat``-specific about the above script.
59+We can generate identity functions at any concrete type using the same script:
64+ mkId = do intro `{{x}}
69+ idNat = %runElab mkId
72+ idUnit = %runElab mkId
74+ idString : String -> String
75+ idString = %runElab mkId
78+Interactively Building Elab Scripts
79+===================================
81+You can build an ``Elab`` script interactively at the REPL.
82+Use the command ``:metavars``, or ``:m`` for short, to list the available holes.
83+Then, issue the ``:elab <hole>`` command at the REPL
84+to enter the elaboration shell.
86+At the shell, you can enter proof tactics to alter the proof state.
87+You can view the system-provided tactics prior to entering the shell
88+by issuing the REPL command ``:browse Language.Reflection.Elab.Tactics``.
89+When you have discharged all goals, you can complete the proof
90+using the ``:qed`` command and receive in return an elaboration script
93+The interactive elaboration shell accepts a limited number of commands,
94+including a subset of the commands understood by the normal Idris REPL
95+as well as some elaboration-specific commands. It also supports the
96+``do``-syntax, meaning you can write ``res <- command`` to bind the result of
97+``command`` to variable ``res``.
99+General-purpose commands:
101+- ``:eval <EXPR>``, or ``:e <EXPR>`` for short, evaluates the provided expression
102+ and prints the result.
104+- ``:type <EXPR>``, or ``:t <EXPR>`` for short, prints the provided expression
105+ together with its type.
107+- ``:search <TYPE>`` searches for definitions having the provided type.
109+- ``:doc <NAME>`` searches for definitions with the provided name and prints their
113+Commands for viewing the proof state:
115+- ``:state`` displays the current state of the term being constructed. It lists both
116+ other goals and the current goal.
118+- ``:term`` displays the current proof term as well as its yet-to-be-filled holes.
121+Commands for manipulating the proof state:
123+- ``:undo`` undoes the effects of the last tactic.
125+- ``:abandon`` gives up on proving the current lemma and quits the elaboration shell.
127+- ``:qed`` finishes the script and exits the elaboration shell. The shell will only accept
128+ this command once it reports, "No more goals." On exit, it will print out the finished
129+ elaboration script for you to copy into your program.
135+Some tactics may *fail*.
136+For example, ``intro`` will fail if the focused hole does not have a function type, ``solve`` will fail if the current hole does not contain a guess, and ``fill`` will fail if the term to be filled in has the wrong type.
137+Scripts can also fail explicitly using the ``fail`` tactic.
139+To account for failure, there is an ``Alternative`` implementation for ``Elab``.
140+The ``<|>`` operator first tries the script to its left.
141+If that script fails, any changes that it made to the state are undone and the right argument is executed.
142+If the first argument succeeds, then the second argument is not executed.
144+Querying the Elaboration State
145+==============================
147+``Elab`` includes operations to query the elaboration state, allowing scripts to use information about their environment to steer the elaboration process.
148+The ordinary Idris bind syntax can be used to propagate this information.
149+For example, a tactic that solves the current goal when it is the unit type might look like this:
151+.. code-block:: idris
157+ `(() : Type) => do fill `(() : ())
159+ otherGoal => fail [ TermPart otherGoal
160+ , TextPart "is not trivial"
164+The tactic ``compute`` normalises the type of its goal with respect to the current context.
165+While not strictly necessary, this allows ``triv`` to be used in contexts where the triviality of the goal is not immediately apparent.
166+Then, ``getGoal`` is used, and its result is bound to ``g``.
167+Because it returns a pair consisting of the current goal's name and type, we case-split on its second projection.
168+If the goal type turns out to have been the unit type, we fill using the unit constructor and solve the goal.
169+Otherwise, we fail with an error message informing the user that the current goal is not trivial.
171+Additionally, the elaboration state can be dumped into an error message with the ``debug`` tactic.
172+A variant, ``debugMessage``, allows arbitrary messages to be included with the state, allowing for a kind of "``printf`` debugging" of elaboration scripts.
173+The message format used by ``debugMessage`` is the same for errors produced by the error reflection mechanism, allowing the re-use of the Idris pretty-printer when rendering messages.
175+Changing the Global Context
176+===========================
178+``Elab`` scripts can modify the global context during execution.
179+Just as the Idris elaborator produces auxiliary definitions to implement features such as ``where``-blocks and ``case`` expressions, user elaboration scripts may need to define functions.
180+Furthermore, this allows ``Elab`` reflection to be used to implement features such as interface deriving.
181+The operations ``declareType``, ``defineFunction``, and ``addImplementation`` allow ``Elab`` scripts to modify the global context.
183+Using Idris's Features
184+======================
186+The Idris compiler has a number of ways to automate the construction of terms.
187+On its own, the ``Elab`` state and its interactions with the unifier allow implicits to be solved using unification.
188+Additional operations use further features of Idris.
189+In particular, ``resolveTC`` solves the current goal using interface resolution, ``search`` invokes the proof search mechanism, and ``sourceLocation`` finds the context in the original file at which the elaboration script is invoked.
192+Recursive Elaboration
193+=====================
195+The elaboration mechanism can be invoked recursively using the ``runElab`` tactic.
196+This tactic takes a goal type and an elaboration script as arguments and runs the script in a fresh lexical environment to create an inhabitant of the provided goal type.
197+This is primarily useful for code generation, particularly for generating pattern-matching clauses, where variable scope needs to be one that isn't the present local context.
202+Some tactics are introduced in the :ref:`proofs-index` section with further details, of those most relevant to elaborator reflection, on the following pages.
204+The list of built-in tactics can be obtained using the ``:browse`` command in an Idris REPL or the corresponding feature in one of the graphical IDE clients to explore the ``Language.Reflection.Elab.Tactics`` namespace.
205+All of the built-in tactics contain documentation strings.
207+For alternative ways to extend the Idris language see the :ref:`reference-index` section.
209+The following pages explain more about the theory and practice of elaborator reflection.
docs/elaboratorReflection/example1.rstnew file+192
@@ -0,0 +1,192 @@
1+Elaborator Reflection - Identity Example
2+========================================
6+ * - This example of elaborator reflection steps through this metaprogram that generates the identity function:
7+ - .. code-block:: idris
9+ %language ElabReflection
12+ idNat = %runElab (do intro `{{x}}
19+ * - At the beginning of executing the elaboration script, the initial state consists of a single hole of type Nat -> Nat.
21+ As a first approximation, the state consists of a term with holes in it, an indicator of which hole is focused, a queue of the next holes to focus on, and miscellaneous information like a source of fresh names. The intro tactic modifies this state, replacing the focused hole with a lambda and focusing on the lambda's body.
22+ - .. image:: ../image/tree.png
26+The following is a walkthough looking at the state after each tactic:
30+ * - Start with the type signature like this:
31+ - .. code-block:: idris
33+ %language ElabReflection
38+ * - In order to investigate how the program works this table shows the proof state at each stage as the tactics are applied. So here is the proof state at the start:
39+ - .. image:: ../image/elabProofStateEx1_1.png
43+ * - This table shows the hole types and what they depend on. The aim is to illustrate the types by analogy with proofs, as a line with the premises above it and the conclusion below it.
44+ - .. image:: ../image/elabLogicEx1_1.png
49+ - ?{hole_0} ≈ ? {hole_2} . {hole_2} . {hole_0}
51+ * - It is possible to read the state from the script by calling getEnv, getGoal and getHoles.
53+ - The output of these calls contain structures with TT code. To show the results I hacked this: `my code`_. TT code is not really designed to be readable by humans, all the names are fully expanded, everything has a type down to universes (type of types). This is shown here to illustrate the information available.
55+ .. code-block:: idris
59+ getGoal=(hole_2, __pi_arg:(Nat.["Nat", "Prelude"]:{
60+ type constructor tag=8 number=0}.Type:U=(20:./Prelude/Nat.idr)->.
61+ {name ref{type constructor tag=8 number=0}Nat.["Nat","Prelude"]:
62+ Type:U=(20:./Prelude/Nat.idr)
66+ getHoles=[{hole_2},{hole_0}]
71+ * - Introduce a lambda binding around the current hole and focus on the body.
74+ * - The state now looks like this:
75+ - .. image:: ../image/elabProofStateEx1_2.png
79+ * - The hole types now looks like this:
80+ - .. image:: ../image/elabLogicEx1_2.png
84+ * - The term now looks like this:
85+ - ?{hole_0} ≈ λ x . ? {hole_2} . {hole_2} . {hole_0}
87+ * - Again we can check the state by calling getEnv, getGoal and getHoles: see `my code`_
89+ - .. code-block:: idris
91+ getEnv=[(x, {λ (Nat.["Nat", "Prelude"]:{
92+ type constructor tag=8 number=0}).
93+ Type:U=(20:./Prelude/Nat.idr)
96+ getGoal=(hole_2, {name ref{type constructor tag=8 number=0}
97+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)
100+ getHoles=[{hole_2},{hole_0}]
105+ * - Place a term into a hole, unifying its type
106+ - fill (Var \`{{x}})
108+ * - The state still looks like this:
109+ - .. image:: ../image/elabProofStateEx1_3.png
113+ * - The hole types now looks like this:
114+ - .. image:: ../image/elabLogicEx1_3.png
118+ * - The term now looks like this:
119+ - ?{hole_0} ≈ λ x . ?{hole_2} ≈ x . {hole_2} . {hole_0}
121+ * - Again we can check the state by calling getEnv, getGoal and getHoles: see `my code`_
123+ - .. code-block:: idris
125+ getEnv=[(x, {λ (Nat.["Nat", "Prelude"]:
126+ {type constructor tag=8 number=0}).
127+ Type:U=(20:./Prelude/Nat.idr)
130+ getGoal=(hole_2, {name ref{type constructor tag=8 number=0}
131+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)
134+ getHoles=[{hole_2}, {hole_0}]
137+ - .. code-block:: idris
140+ {name ref{type constructor tag=8 number=0}
141+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)
145+ * - Substitute a guess into a hole.
148+ * - The hole types now looks like this:
149+ - .. image:: ../image/elabLogicEx1_4.png
153+ * - The term now looks like this:
154+ - ?{hole_0} ≈ λ x . x . {hole_0}
162+ - .. code-block:: idris
166+ getGoal=(hole_0, __pi_arg:(Nat.["Nat", "Prelude"]:{
167+ type constructor tag=8 number=0}.
168+ Type:U=(20:./Prelude/Nat.idr)
170+ {type constructor tag=8 number=0}
171+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)
178+ - .. code-block:: idris
180+ x:({λ (Nat.["Nat", "Prelude"]:{
181+ type constructor tag=8 number=0}).
182+ Type:U=(20:./Prelude/Nat.idr)
185+ x:{name ref {type constructor tag=8 number=0}
186+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)
192+.. _`my code`: https://github.com/martinbaker/Idris-dev/blob/uglyTTPrinter/libs/prelude/Language/Reflection/TTPrinter.idr
docs/elaboratorReflection/generatingData.rstnew file+385
@@ -0,0 +1,385 @@
1+Generating Datatypes and Functions at Compile Time
2+==================================================
4+Program elements, such as datatypes and functions can be constructed at compile-time in the Elab monad.
5+This can allow proofs to be generated for user defined types or it could allow types to be automatically generated to support user defined types.
6+An example is the code, from `Elaborator reflection: extending Idris in Idris`_, that automatically generates accessibility predicates using the Bove-Capretta method.
11+There are two main 'tactics' associated with generating datatypes:
16+Which declare and define the datatype as the names suggest.
20+ * - These 'tactics' and the data structures associated with them are listed in the tables later on this page, for now, here is a summary:
21+ - .. image:: ../image/generateDatatype.png
24+ :alt: diagram illustrating data structures associated with declareDatatype defineDatatype.
28+ * - As a first example, the following boolean-like type can be constructed. When the compiler has run it will be available to us as if we had compiled it in the usual way:
29+ - .. code-block:: idris
32+ data Two : Type where
36+This was generated by the following code:
41+ %language ElabReflection
44+ addTwo = do let twoname : TTName = `{{TwoDef.Two}}
45+ let F2 = `{{TwoDef.F}}
46+ let T2 = `{{TwoDef.T}}
47+ declareDatatype $ Declare twoname [] `(Type)
48+ defineDatatype $ DefineDatatype twoname [
49+ Constructor `{{F}} [] (Var `{{TwoDef.Two}}),
50+ Constructor `{{T}} [] (Var `{{TwoDef.Two}})
57+ * - The constructors T and F can be called as would be expected:
58+ - .. code-block:: idris
68+There are two main 'tactics' associated with generating functions:
73+Which declare and define the function as the names suggest.
77+ * - These 'tactics' and the data structures associated with them are listed in the tables later on this page, for now, here is a summary:
78+ - .. image:: ../image/generateFunction.png
81+ :alt: diagram illustrating data structures associated with function declare and define.
83+Note: The left hand side (lhs) and right hand side (rhs) of FunClause typically is of type 'Raw'.
87+ * - Bound pattern variables are represented by 'PVar' binders:
88+ This diagram shows an example of a possible Raw structure that might be used in a function definition.
89+ - .. image:: ../image/generateFunction2.png
92+ :alt: diagram illustrating data structures associated with functions.
96+ * - Some function definitions can now be added to the above datatype. This is what they will look like:
97+ - .. code-block:: idris
108+This was generated with the following code:
110+.. code-block:: idris
112+ let perm1 = `{{TwoDef.perm1}}
113+ declareType (Declare perm1 [MkFunArg `{{code}} (Var twoname) Explicit NotErased] (Var twoname))
114+ defineFunction $ DefineFun perm1 [
115+ MkFunClause (RApp (Var perm1) (Var `{{TwoDef.F}})) (Var F2),
116+ MkFunClause (RApp (Var perm1) (Var `{{TwoDef.T}})) (Var T2)
119+ let perm2 = `{{TwoDef.perm2}}
120+ declareType (Declare perm2 [MkFunArg `{{code}} (Var twoname) Explicit NotErased] (Var twoname))
121+ defineFunction $ DefineFun perm2 [
122+ MkFunClause (RApp (Var perm1) (Var `{{TwoDef.F}})) (Var T2),
123+ MkFunClause (RApp (Var perm1) (Var `{{TwoDef.T}})) (Var F2)
128+ * - This is what happens when we call the functions:
129+ - .. code-block:: idris
140+So far these datatypes and functions could have been written, statically, in the usual way. However, it is possible to imagine situations where we may need a lot of functions to be generated automatically at compile time. For example, if we extend this Boolean datatype to a datatype with more simple constructors (a finite set), we could generate a function for every possible permutation of that datatype back to itself.
142+A Different Example which has Type Parameters
143+---------------------------------------------
147+ * - Here is an example of a datatype with type parameters:
148+ - .. code-block:: idris
150+ data N : Nat -> Type where
152+ MkN' : (x : Nat) -> N (S x)
154+This was produced by the following code:
156+.. code-block:: idris
159+ %language ElabReflection
163+ let dataname : TTName = `{{DataDef.N}}
164+ declareDatatype $ Declare dataname [MkFunArg `{{n}} `(Nat) Explicit NotErased] `(Type)
165+ defineDatatype $ DefineDatatype dataname [
166+ Constructor `{{MkN}} [MkFunArg `{{x}} `(Nat) Implicit NotErased]
167+ (RApp (Var dataname) (Var `{{x}})),
168+ Constructor `{{MkN'}} [MkFunArg `{{x}} `(Nat) Explicit NotErased]
169+ (RApp (Var dataname) (RApp (Var `{S}) (Var `{{x}})))
174+So this declares and defines the following data structure 'N' with a constructor 'MkN' which can have an implicit or an explicit Nat argument. Which can be used like this:
176+.. code-block:: idris
187+Table of 'tactics' for Generating Data and Functions
188+----------------------------------------------------
190+These are the functions that we can use to create data and functions in the Elab monad:
197+ - Add a type declaration to the global context.
201+ declareType : TyDecl -> Elab ()
203+ - Define a function in the global context. The function must have already been declared, either in ordinary Idris code or using `declareType`.
207+ defineFunction : FunDefn Raw -> Elab ()
210+ - Declare a datatype in the global context. This step only establishes the type constructor; use `defineDatatype` to give it constructors.
214+ declareDatatype : TyDecl -> Elab ()
219+ defineDatatype : DataDefn -> Elab ()
221+ * - addImplementation
222+ - Register a new implementation for interface resolution.
226+ - ifaceName the name of the interface for which an implementation is being registered
227+ - implName the name of the definition to use in implementation search
231+ addImplementation : (ifaceName, implName : TTName) -> Elab ()
234+ - Determine whether a name denotes an interface.
238+ - name - a name that might denote an interface.
242+ isTCName : (name : TTName) -> Elab Bool
244+Table of Datatypes Associated with Generating Data and Functions
245+----------------------------------------------------------------
247+The above functions use the following data/records:
254+ - How an argument is provided in high-level Idris
256+ .. code-block:: idris
259+ ||| The argument is directly provided at the application site
261+ ||| The argument is found by Idris at the application site
263+ ||| The argument is solved using interface resolution
267+ - Function arguments
269+ These are the simplest representation of argument lists, and are used for functions. Additionally, because a FunArg provides enough
270+ information to build an application, a generic type lookup of a top-level identifier will return its FunArgs, if applicable.
272+ .. code-block:: idris
275+ constructor MkFunArg
282+ - Type constructor arguments
284+ Each argument is identified as being either a parameter that is
286+ consistent in all constructors, or an index that varies based on
288+ which constructor is selected.
290+ .. code-block:: idris
293+ ||| Parameters are uniform across the constructors
294+ TyConParameter FunArg |
295+ ||| Indices are not uniform
299+ - A type declaration for a function or datatype
301+ .. code-block:: idris
305+ ||| The fully-qualified name of the function or datatype being declared.
307+ ||| Each argument is in the scope of the names of previous arguments.
308+ arguments : List FunArg
309+ ||| The return type is in the scope of all the argument names.
313+ - A single pattern-matching clause
315+ .. code-block:: idris
317+ data FunClause : Type -> Type where
318+ MkFunClause : (lhs, rhs : a) -> FunClause a
319+ MkImpossibleClause : (lhs : a) -> FunClause a
322+ - A reflected function definition.
324+ .. code-block:: idris
326+ record FunDefn a where
327+ constructor DefineFun
329+ clauses : List (FunClause a)
332+ - A constructor to be associated with a new datatype.
334+ .. code-block:: idris
336+ record ConstructorDefn where
337+ constructor Constructor
338+ ||| The name of the constructor. The name must _not_ be qualified -
339+ ||| that is, it should begin with the `UN` or `MN` constructors.
341+ ||| The constructor arguments. Idris will infer which arguments are
342+ ||| datatype parameters.
343+ arguments : List FunArg
344+ ||| The specific type constructed by the constructor.
348+ - A definition of a datatype to be added during an elaboration script.
350+ .. code-block:: idris
352+ record DataDefn where
353+ constructor DefineDatatype
354+ ||| The name of the datatype being defined. It must be
355+ ||| fully-qualified, and it must have been previously declared as a
358+ ||| A list of constructors for the datatype.
359+ constructors : List ConstructorDefn
364+ .. code-block:: idris
366+ data CtorArg = CtorParameter FunArg | CtorField FunArg
369+ - A reflected datatype definition
371+ .. code-block:: idris
373+ record Datatype where
374+ constructor MkDatatype
375+ ||| The name of the type constructor
377+ ||| The arguments to the type constructor
378+ tyConArgs : List TyConArg
379+ ||| The result of the type constructor
381+ ||| The constructors for the family
382+ constructors : List (TTName, List CtorArg, Raw)</td>
385+.. _`Elaborator reflection: extending Idris in Idris`: https://dl.acm.org/citation.cfm?doid=2951913.2951932
docs/elaboratorReflection/holes.rstnew file+196
@@ -0,0 +1,196 @@
1+Elaborator Reflection - Holes
2+=============================
4+The process of doing proofs and elaborator reflection tends to involve stating with a desired conclusion and working back to known premises. This often needs intermediate sub-goals which may only be partially solved, these are encoded using 'holes' and 'guesses'.
6+* A hole is a term (an expression - a chunk of code) which is yet to be determined. We do have information about its type (this process tends to be type driven).
7+* A guess is like a hole that is not yet bound.
9+The theory around this was developed in `Dependently Typed Functional Programs and their Proofs by McBride 1999`_.
11+Notation for Holes and Guesses
12+------------------------------
14+There is a notation used in the McBride 1999 thesis which is adapted for the TT language. When working on elaborator reflection it is useful to know this notation, for instance when reading the output of the 'debug' tactic.
16+* A focused hole is notated like this ?x:t . t
17+* A guess is notated like this ?x ≈ t:t . t
19+The following example shows how this is used:
24+Start with a code file that just contains:
28+ %language ElabReflection
31+ testFn = %runElab (do debug {a = ()})
33+when this is loaded the following is displayed:
38+ ----------------------------------
39+ {hole_2} : Prelude.Nat.Nat
41+ ----------------------------------
42+ {hole_0} : Prelude.Nat.Nat
45+ ?{hole_0} ≈ ? {hole_2} . {hole_2} . {hole_0}
47+This shows information about the state when debug is encountered, during tactic execution, which allows us to investigate what is happening at each stage.
49+* The "Holes" part shows the types of the holes and the local context of each
50+* The "Term" part shows where these holes are in the expression being constructed.
52+So starting with the "Term" part we have.
56+ ?{hole_0} ≈ ? {hole_2} . {hole_2} . {hole_0}
58+.. sidebar:: attack tactic
60+ This kind of thing tends to arise from "attack", which helps keep binding forms in order.
62+The meaning of this is not immediately apparent so it helps to add some parentheses to make the structure clearer:
66+ (?{hole_0} ≈ (? {hole_2} . {hole_2}) . {hole_0})
68+First lets look at the inner part:
72+ ? {hole_2} . {hole_2}
74+We can substitute in the type from the "Holes" part:
78+ ? {hole_2}:Nat . {hole_2}:Nat
80+So we are looking for a hole of type Nat and all we know is it has type Nat.
82+Going back to the full term, the above is wrapped in a guess, so it means: 'a guess that is itself a hole'.
84+Since the elaborator does not have any further information it has to be given a value:
88+ %language ElabReflection
91+ testFn = %runElab (do fill `(Z)
95+Now we have a guess for hole_2 which is itself a guess for hole_0:
99+ ?{hole_0} ≈ ?{hole_2} ≈ Prelude.Nat.Z . {hole_2} . {hole_0}
101+The guesses can be accepted by calling the 'solve' tactic.
103+Example Showing Patterns
104+------------------------
106+In this next example a parameter 'n' has been added to the function. This allows us to see how patterns are used. Starting with this file:
108+.. code-block:: idris
110+ %language ElabReflection
113+ testFn n = %runElab (do debug {a = ()})
117+.. code-block:: idris
121+ ----------------------------------
122+ {hole_3} : Prelude.Nat.Nat
125+ ----------------------------------
126+ {hole_1} : Prelude.Nat.Nat
128+ ----------------------------------
129+ {hole_0} : patTy n : Prelude.Nat.Nat . Prelude.Nat.Nat
132+ ?{hole_0} ≈ pat n : Prelude.Nat.Nat .
133+ ?{hole_1} ≈ ? {hole_3} . {hole_3} . {hole_1} .
136+The ns above the lines show the context of the holes on the right hand side - they include the variable n that is an argument!
138+patTy is a binding form in Idris's core language that introduces a pattern variable. The idea is that the left-hand side and right-hand side of each pattern should have the same type. Because pattern variables may occur multiple times on either side of the equation, we can achieve this by documenting their types with a binding form that wraps each side. This new binding form is why an "attack" was necessary prior to elaborating the RHS.
140+patTy is a type former, and pat is the corresponding introduction form. So you can think of patTy as being a bit like a dependent function type, and pat as being a bit like lambda, except they don't introduce functions (they instead are used for pattern-matching definitions).
142+More Complicated Example
143+------------------------
145+This example does not introduce any new notation but the extra complexity gives a more realistic idea of how it is used. Here we start with this file:
147+.. code-block:: idris
149+ %language ElabReflection
151+ testFn : (n : Nat) -> (n = plus n Z) -> (S n = S (plus n Z))
152+ testFn k ih = %runElab (do debug {a = ()})
156+.. code-block:: idris
160+ ih : = Prelude.Nat.Nat Prelude.Nat.Nat k
161+ (Prelude.Nat.plus k Prelude.Nat.Z)
162+ ----------------------------------
163+ {hole_4} : = Prelude.Nat.Nat Prelude.Nat.Nat (Prelude.Nat.S k)
164+ (Prelude.Nat.S (Prelude.Nat.plus k Prelude.Nat.Z))
167+ ih : = Prelude.Nat.Nat Prelude.Nat.Nat k
168+ (Prelude.Nat.plus k Prelude.Nat.Z)
169+ ----------------------------------
170+ {hole_2} : = Prelude.Nat.Nat Prelude.Nat.Nat (Prelude.Nat.S k)
171+ (Prelude.Nat.S (Prelude.Nat.plus k Prelude.Nat.Z))
174+ ----------------------------------
175+ {hole_1} : patTy ih : = Prelude.Nat.Nat Prelude.Nat.Nat k
176+ (Prelude.Nat.plus k Prelude.Nat.Z) .
177+ = Prelude.Nat.Nat Prelude.Nat.Nat (Prelude.Nat.S k)
178+ (Prelude.Nat.S (Prelude.Nat.plus k Prelude.Nat.Z))
180+ ----------------------------------
181+ {hole_0} : patTy k : Prelude.Nat.Nat .
182+ patTy ih : = Prelude.Nat.Nat Prelude.Nat.Nat k
183+ (Prelude.Nat.plus k Prelude.Nat.Z) .
184+ = Prelude.Nat.Nat Prelude.Nat.Nat (Prelude.Nat.S k)
185+ (Prelude.Nat.S (Prelude.Nat.plus k Prelude.Nat.Z))
188+ ?{hole_0} ≈ pat k : Prelude.Nat.Nat .
189+ ?{hole_1} ≈ pat ih : = Prelude.Nat.Nat Prelude.Nat.Nat k
190+ (Prelude.Nat.plus k Prelude.Nat.Z) .
191+ ?{hole_2} ≈ ? {hole_4} . {hole_4} . {hole_2} .
196+.. _`Dependently Typed Functional Programs and their Proofs by McBride 1999`: https://www.era.lib.ed.ac.uk/handle/1842/374
docs/elaboratorReflection/index.rstnew file+27
@@ -0,0 +1,27 @@
7+A tutorial on theorem proving in Idris.
11+ The documentation for Idris has been published under the Creative
12+ Commons CC0 License. As such to the extent possible under law, *The
13+ Idris Community* has waived all copyright and related or neighboring
14+ rights to Documentation for Idris.
16+ More information concerning the CC0 can be found online at: http://creativecommons.org/publicdomain/zero/1.0/
21+ elaborator-reflection
docs/elaboratorReflection/primitive.rstnew file+518
@@ -0,0 +1,518 @@
9+ - Generate a unique name based on some hint.
11+ Useful when establishing a new binder.
13+ **NB**: the generated name is unique **for this run of the elaborator**.
15+ Do not assume that they are globally unique.
19+ gensym : (hint : String) -> Elab TTName
22+ - Substitute a guess into a hole.
25+ .. image:: ../image/solve.png
28+ :alt: diagram illustrating solve tactic
31+ Substitute the focused guess throughout its scope, eliminating it and moving focus to the next element of the hole queue. Fail if the focus is not a guess.
39+ .. code-block:: idris
41+ %language ElabReflection
44+ testFn = %runElab (do fill `(Z)
48+ - Place a term into a hole, unifying its type. Fails if the focus is not a hole.
51+ .. image:: ../image/fill.png
54+ :alt: diagram illustrating fill tactic
59+ fill : (e : Raw) -> Elab ()
61+ Place a term e with type tc into the focused hole:
65+ and convert it to a guess:
69+ and fail if the current focus is not a hole. The type t of the guess is constructed by unifying tc and th, which may instantiate holes that they refer to. Fail if the current focus is not a hole or if unification fails.
71+ This unification can result in the solution of further holes or the establishment of additional unsolved unification constraints.
75+ .. code-block:: idris
77+ %language ElabReflection
80+ testFn = %runElab (do fill `(Z)
84+ - Attempt to apply an operator to fill the current hole, potentially solving arguments by unification.
86+ A hole is established for each argument.
88+ The return value is the list of holes established for the arguments to the function.
90+ Note that not all of the returned hole names still exist, as they may have been solved.
92+ - @ op the term to apply
93+ - @ argSpec - A list of booleans, one for each argument that the operator will be applied to. If true then attempt to solve the argument by unification.
97+ apply : (op : Raw) -> (argSpec : List Bool) -> Elab (List TTName)
99+ Example: elaborating an application of a function f that takes one implicit and two explicit arguments might invoke:
101+ apply \`(f) [False, True, True]
103+ Here is an example of an elab script that uses apply to insert the term plus Z (S Z) into a goal of type Nat.
105+ .. code-block:: idris
107+ do [x,y] <- apply `(plus) [False, False]
109+ focus x; fill `(Z); solve
110+ focus y; fill `(S Z); solve
112+ The names of the established holes are returned.
114+ Note: This was added to the original tactic language to allow elaborator reflection.
117+ - Attempt to apply an operator to fill the current hole, potentially solving arguments by matching.
119+ The return value is the list of holes established for the arguments to the function.
121+ Note that not all of the returned hole names still exist, as they may have been solved.
123+ - @ op the term to apply
124+ - @ argSpec instructions for finding the arguments to the term, where the Boolean states whether or not to attempt to solve the argument by matching.
128+ matchApply : (op : Raw) -> (argSpec : List Bool) -> Elab (List TTName)
131+ - Move the focus to the specified hole, bringing it to the front of the hole queue. Fails if the hole does not exist.
133+ @ hole the hole to focus on
137+ focus : (hole : TTName) -> Elab ()
140+ - Send the currently-focused hole to the end of the hole queue and focus on the next hole.
144+ unfocus : TTName -> Elab ()
147+ - Convert a hole to make it suitable for bindings.
150+ .. image:: ../image/attack.png
153+ :alt: diagram illustrating attack tactic
156+ The binding tactics require that a hole be directly under its binding, or else the scopes of the generated terms won't make sense. This tactic creates a new hole of the proper form, and points the old hole at it.
163+ - Establish a new hole binding named n with type t, surrounding the current focus.
165+ Introduce a new hole with a specified name and type.
167+ The new hole will be focused, and the previously-focused hole will be immediately after it in the hole queue. Because this tactic introduces a new binding, you may need to 'attack' first.
171+ claim : TTName -> Raw -> Elab ()
174+ - Convert a hole into a pattern variable.
178+ patvar : TTName -> Elab ()
181+ - Normalise the goal.
183+ Often this is not necessary because normanisation is applied during other tactics.
190+ - Normalise a term in some lexical environment
192+ - @ env the environment in which to compute (get one of these from `getEnv`)
193+ - @ term the term to normalise
197+ normalise : (env : List (TTName, Binder TT)) -> (term : TT) -> Elab TT
200+ - Reduce a closed term to weak-head normal form
202+ @ term the term to reduce
206+ whnf : (term : TT) -> Elab TT
209+ - Check that two terms are convertible in the current context and in some environment.
211+ - @ env a lexical environment to compare the terms in (see `getEnv`)
212+ - @ term1 the first term to convert
213+ - @ term2 the second term to convert
217+ convertsInEnv : (env : List (TTName, Binder TT)) -> (term1, term2 : TT) -> Elab ()
220+ - Check that two terms are convertable in the current context and environment
222+ - @ term1 the first term to convert
223+ - @ term2 the second term to convertconverts : (term1, term2 : TT) -> Elab ()
225+ converts term1 term2 = convertsInEnv !getEnv term1 term2
227+ * - getSourceLocation
228+ - Find the source context for the elaboration script
232+ getSourceLocation : Elab SourceLocation
235+ - Attempt to solve the current goal with the source code
237+ locationsourceLocation : Elab ()
239+ .. code-block:: idris
241+ sourceLocation = do loc <- getSourceLocation
245+ * - currentNamespace
246+ - Get the current namespace at the point of tactic execution. This allows scripts to define top-level names conveniently.
248+ The namespace is represented as a reverse-order list of strings, just as in the representation of names.
252+ currentNamespace : Elab (List String)
255+ - Attempt to rewrite the goal using an equality.
257+ The tactic searches the goal for applicable subterms, and constructs a context for `replace` using them. In some cases, this is not possible, and `replace` must be called manually with an appropriate context.
259+ Because this tactic internally introduces a `let` binding, it requires that the hole be immediately under its binder (use 'attack' if it might not be).
263+ rewriteWith : Raw -> Elab ()
266+ - Attempt to solve the current goal with an interface dictionary
268+ @ fn the name of the definition being elaborated (to prevent Idris from looping)
272+ resolveTC : (fn : TTName) -> Elab ()
275+ - Use Idris's internal proof search.
282+ - Use Idris's internal proof search, with more control.
284+ - @ depth the search depth
285+ - @ hints additional names to try
289+ search' : (depth : Int) -> (hints : List TTName) -> Elab ()
292+ - Look up the declared fixity for an operator.
294+ The lookup fails if the operator does not yet have a fixity or if the string is not a valid operator.
296+ @ operator the operator string to look up
300+ operatorFixity : (operator : String) -> Elab Fixity
303+ - Halt elaboration, dumping the internal state for inspection.
305+ This is intended for elaboration script developers, not for end-users. Use `fail` for final scripts.
311+ If 'debug' is not the last tactic then make sure its type is sufficiently constrained. In particular, its type is Elab a, but there's no way for Idris to find out which type was meant for a. This can be fixed by either writing an explicit type (e.g. debug {a = ()}) or by using a helper that constrains the type (such as simple in Pruviloj, e.g. simple debug as a line).
313+ .. code-block:: idris
315+ %language ElabReflection
318+ idNat = %runElab (do intro `{{x}}
324+ - Halt elaboration, dumping the internal state and displaying a message.
326+ This is intended for elaboration script developers, not for end-users. Use `fail` for final scripts.
328+ @ msg the message to display
332+ debugMessage : (msg : List ErrorReportPart) -> Elab a
334+ If 'debugMessage' is not the last tactic then make sure its type is sufficiently constrained. In particular, its type is Elab a, but there's no way for Idris to find out which type was meant for a. This can be fixed by either writing an explicit type (e.g. debugMessage [TextPart "message"] {a = ()}) or by using a helper that constrains the type (such as simple in Pruviloj, e.g. simple debug as a line).
336+ .. code-block:: idris
338+ %language ElabReflection
340+ idNat = %runElab (do intro `{{x}}
341+ debugMessage [TextPart "error message"] {a = ()}
346+ - Create a new top-level metavariable to solve the current hole.
348+ @ name the name for the top-level variable
352+ metavar : (name : TTName) -> Elab ()
355+ - Recursively invoke the reflected elaborator with some goal.
357+ The result is the final term and its type.
361+ runElab : Raw -> Elab () -> Elab (TT, TT)
372+ - Look up the lexical binding at the focused hole. Fails if no holes are present.
376+ getEnv : Elab (List (TTName, Binder TT))
379+ - Get the name and type of the focused hole. Fails if not holes are present.
383+ getGoal : Elab (TTName, TT)
386+ - Get the hole queue, in order.
390+ getHoles : Elab (List TTName)
393+ - If the current hole contains a guess, return it. Otherwise, fail.
400+ - Look up the types of every overloading of a name.
404+ lookupTy : TTName -> Elab (List (TTName, NameType, TT))
407+ - Get the type of a fully-qualified name. Fail if it doesn't resolve uniquely.
411+ lookupTyExact : TTName -> Elab (TTName, NameType, TT)
414+ - Find the reflected representation of all datatypes whose names are overloadings of some name.
418+ lookupDatatype : TTName -> Elab (List Datatype)
420+ * - lookupDatatypeExact
421+ - Find the reflected representation of a datatype, given its fully-qualified name. Fail if the name does not uniquely resolve to a datatype.
425+ lookupDatatypeExact : TTName -> Elab Datatype
428+ - Find the reflected function definition of all functions whose names are overloadings of some name.
432+ lookupFunDefn : TTName -> Elab (List (FunDefn TT))
434+ * - lookupFunDefnExact
435+ - Find the reflected function definition of a function, given its fully-qualified name. Fail if the name does not uniquely resolve to a function.
439+ lookupFunDefnExact : TTName -> Elab (FunDefn TT)
442+ - Get the argument specification for each overloading of a name.
446+ lookupArgs : TTName -> Elab (List (TTName, List FunArg, Raw))
449+ - Get the argument specification for a name. Fail if the name does not uniquely resolve.
453+ lookupArgsExact : TTName -> Elab (TTName, List FunArg, Raw)
456+ - Attempt to type-check a term, getting back itself and its type.
458+ - @ env the environment within which to check the type
459+ - @ tm the term to check
463+ check : (env : List (TTName, Binder TT)) -> (tm : Raw) -> Elab (TT, TT)
473+ - `tryCatch t (\err => t')` will run `t`, and if it fails, roll back the elaboration state and run `t'`,
474+ but with access to the knowledge of why `t` failed.
478+ tryCatch : Elab a -> (Err -> Elab a) -> Elab a
480+ .. code-block:: idris
482+ %language ElabReflection
485+ f (Msg _) = fill `("message error")
486+ f (CantUnify _ _ _ _ _ _) = fill `("unification error")
487+ f _ = fill `("other")
490+ s2 = %runElab (do tryCatch (fill `(True)) f ; solve)
493+ - Halt elaboration with an error
497+ fail : List ErrorReportPart -> Elab a
499+ Note: we may need to make sure the return type 'a' is sufficiently constrained. If required add an explicit type {a = ()}.
501+ Below is some code which includes 'fail'. This will always fail but we could replace 'True' with some more useful condition.
503+ .. code-block:: idris
505+ %language ElabReflection
513+ fail [TextPart "put error message here"]
518+ idNat = %runElab id1
docs/elaboratorReflection/tactics.rstnew file+430
@@ -0,0 +1,430 @@
1+Elaborator Reflection - Tactics
2+===============================
4+The Idris part of the code for elaborator reflection is in
5+Elab.idr `<https://github.com/idris-lang/Idris-dev/blob/master/libs/prelude/Language/Reflection/Elab.idr>`_
6+Before looking at the Elab monad we need to know how to construct terms.
12+The terminology 'Proof State' is used by analogy to proof assistants but, as used here, it's really more of a metaprogramming state.
14+Tactics operate on the proof state. The proof state contains various pieces of information, at this stage, the important ones for us are:
16+- A hole queue - This contains a list of the names of the holes used in the proof term. The solution to each hole may depend on the other holes. For more information about holes and guesses see `Dependently Typed Functional Programs and their Proofs by McBride 1999`_.
17+- A goal type - The type of the term that is under construction for the current goal.
18+- A possibly incomplete proof term, which is being calculated and should be the goal type at the end of elaboration.
19+- Context - A collection of open unification problems, representing recoverable failures of unification that may yet unify once more variables are solved.
21+There are many other pieces of information in the proof state such as the names used , such as the bodies of case blocks that need to be elaborated.but, for now, we will leave the system to handle these.
23+.. image:: ../image/elabProofState.png
30+Names in an Idris program are evaluated at runtime but sometimes a 'variable name' is needed, which can be referred to as an unevaluated symbol.
31+The names used in terms have different constructors depending on their type:
33++---------------------------+-----------------------------------------------+
34+| UN String | A user-provided name |
35++---------------------------+-----------------------------------------------+
36+| NS (UN "foo") ["B", "A"]) | A name in some namespace |
37++---------------------------+-----------------------------------------------+
38+| MN Int String | Machine-chosen names |
39++---------------------------+-----------------------------------------------+
40+| SN SpecialName | Special names, to make conflicts impossible |
41+| | and language features predictable |
42++---------------------------+-----------------------------------------------+
45+A user defined name can be constructed like this:
54+ Idris> NS (UN "x") ["b","a"]
55+ NS (UN "x") ["b", "a"] : TTName
57+.. list-table:: machine-chosen names
59+ * - A machine-chosen name needs to be generated within an Elab monad (see below for details) and is unique within that monad. This produced: {abc_140}{abc_141} so although gensym "abc" was called twice each one had a different integer:
60+ - example of unique names:
62+ .. code-block:: idris
64+ implementation Show TTName where
65+ show (UN s) = "`{{"++s++"}}"
66+ show (NS t a) = "{"++(show t)++
68+ show (MN i s) = "{"++s++"_"++(show i)++"}"
69+ show (SN sn) = "TTName special name"
72+ showGensym = %runElab (do
73+ debugMessage [TextPart (
74+ show !(gensym "abc") ++
82+Since names are used frequently in elaborator reflection there is a shortcut for constructing them:
86+ * - An unresolved variable "x" is wrapped in backtick and double braces:
87+ - .. code-block:: idris
93+ * - Single braces are used for existing variables:
94+ - .. code-block:: idris
103+ * - brackets are used for an expression:
105+ here type is inferable
106+ - .. code-block:: idris
110+ P Ref (UN "a") (TConst (AType (ATInt ITBig))) : TT
113+ * - Expression with explicit type:
114+ - .. code-block:: idris
117+ P Ref (UN "a") (TConst (AType (ATInt ITBig))) : TT
120+ * - If we want the value we can escape from quasiquotation by using anti-quotation (tilde)
121+ - .. code-block:: idris
126+quasiquotation summary:
128++------------+-----------+----------------------------------------------------------+
130++============+===========+==========================================================+
131+| \`{{n}} | TTName | Use for new names. Unresolved quotation of the name n. |
132++------------+-----------+----------------------------------------------------------+
133+| \`{n} | TTName | Use for existing names. Resolved quotation of the name |
134+| | | n. n is a reference to a unique name in scope. |
135++------------+-----------+----------------------------------------------------------+
136+| \`(e) | | expression e for which a type is inferable. |
137++------------+-----------+----------------------------------------------------------+
138+| \`(e:t) | | expression e with a given type e. |
139++------------+-----------+----------------------------------------------------------+
140+| ~a | | anti-quotation - sub region which can be evaluated rather|
142++------------+-----------+----------------------------------------------------------+
143+|(Var\`{{x}})| Raw | |
144++------------+-----------+----------------------------------------------------------+
149+There is a notation for a term in TT as it is being constructed (based on a BNF-like grammar), this is used for example in the debug output, it is a compact way to see the state of the term so it is used here.
150+So internally the program is stored as a tree structure using the following syntax:
152++------------+-------+-------------+---------------------------------------------+
153+| | | Syntax | More Information |
154++============+=======+=============+=============================================+
156++------------+-------+-------------+---------------------------------------------+
158++------------+-------+-------------+---------------------------------------------+
159+| constant | t ::= | c | |
160++------------+-------+-------------+---------------------------------------------+
161+| variable | t ::= | x | |
162++------------+-------+-------------+---------------------------------------------+
163+| variable | t ::= | b.t | so a dot '.' tells us this is some sort of |
164+| binding | | | binding. |
165++------------+-------+-------------+---------------------------------------------+
166+| application| t ::= | t t | As with Idris, juxtaposition indicates |
167+| | | | function application. Note: the same symbol |
168+| | | | 't' is used for both terms, this does not |
169+| | | | imply they are the same term. |
170++------------+-------+-------------+---------------------------------------------+
171+| Type | t ::= | T | |
173++------------+-------+-------------+---------------------------------------------+
174+| Data | t ::= | C | |
176++------------+-------+-------------+---------------------------------------------+
177+| function | b::= | λ c:t | colon ':' separates parameters from body of |
179++------------+-------+-------------+---------------------------------------------+
180+| let binding| b::= | let\|-> t:t | |
181++------------+-------+-------------+---------------------------------------------+
182+| function | b::= | ∀ x:t | |
183++------------+-------+-------------+---------------------------------------------+
184+| Type | c::= | \*i | The universe hierarchy is usually handled |
185+| universe | | | automatically so we can just use\* for the |
186+| | | | type of types. |
187++------------+-------+-------------+---------------------------------------------+
188+| integer | c:== | i | |
190++------------+-------+-------------+---------------------------------------------+
191+|integer type| c:== | Integer | |
192++------------+-------+-------------+---------------------------------------------+
193+| string | c:== | s | |
195++------------+-------+-------------+---------------------------------------------+
196+| string type| c:== | String | |
197++------------+-------+-------------+---------------------------------------------+
198+|focused hole| | ?x : t | Conor McBride 1999 thesis. |
199++------------+-------+-------------+---------------------------------------------+
200+| guess | | ?x ≈ t : t | Conor McBride 1999 thesis. |
201++------------+-------+-------------+---------------------------------------------+
203+Sometimes the part of the term in focus is underlined.
205+Reflection of the well typed core language
207+.. code-block:: idris
210+ ||| A reference to some name (P for Parameter)
211+ P NameType TTName TT |
212+ ||| de Bruijn variables
215+ Bind TTName (Binder TT) TT |
216+ ||| Apply one term to another
218+ ||| Embed a constant
222+ ||| The type of types along (with universe constraints)
224+ ||| Alternative universes for dealing with uniqueness
227+TT stores local bound variables using De Bruijn index, when working in Idris this does not concern the user because string names are used for variables. Converting bound variables internally to index values means that the same variable name can be used, in different lambda terms, without ambiguity and without the need for α-substitution.
228+De Bruijn index which is a integer where:
230+- 0=inside current (inner) lambda term
231+- 1= next outer lambda term
232+- 2= next outer and so on
237+Raw is similar to TT except it is used before types are known. The types should be resolved by the type checker.
239+.. code-block:: idris
242+ ||| Variables, global or local
245+ RBind TTName (Binder Raw) Raw |
248+ ||| The type of types
250+ ||| Alternative universes for dealing with uniqueness
252+ ||| Embed a constant
258+There is a way of notating expressions such as those used in the proof state (example: goal type and proof terms) which is reasonably standard in the papers written about this subject.
260+This notation is not entered directly by metaprogrammers but it is seen, for example in debug output. So this notation is explained here because it is useful to be familiar with it.
262+The notation assumes right-associativity, in the absence of brackets, the term to the right binds more tightly than the one on the left.
263+So, for nested lambda terms:
265++---------------+--------+-------------------+
266+| λ a . λ b . f | means | λ a .( λ b . f) |
267++---------------+--------+-------------------+
269+and the same for function application:
271++---------------+--------+-------------------+
272+| f g x | means | f (g x) |
273++---------------+--------+-------------------+
275+In contrast, in lambda calculus, function application is usually regarded as left-associative,
276+Here are some typical examples of the notation used for expressions:
278++-----------------------+
279+| ? {hole_0} . {hole_0} |
280++-----------------------+
282+The term, to be derived, may start off in this state following something like this:
284+.. code-block:: idris
289+The dot '.' tells us this is some sort of binding.
291++----------------------------------------------+
292+| ?{hole_0} ≈ ? {hole_2} . {hole_2} . {hole_0} |
293++----------------------------------------------+
295+This is a slightly more complicated example arising from:
297+.. code-block:: idris
300+ idNat = %runElab (do
302+This introduces a guess that hole_0 = hole_2 .
304++----------------------------------------------------+
305+| ?{hole_0} ≈ λ x . ? {hole_2} . {hole_2} . {hole_0} |
306++----------------------------------------------------+
308+Following on from the previous example a lambda function is introduced like this:
310+.. code-block:: idris
314+So now the expression is wrapped in a lambda binding.
316++-------------------------------------------------------+
317+| ?{hole_0} ≈ λ x . ?{hole_2} ≈ x . {hole_2} . {hole_0} |
318++-------------------------------------------------------+
320+Following on, we can use the fill tactic like this:
322+.. code-block:: idris
326+which introduces another guess.
328++--------------------------------+
329+| ?{hole_0} ≈ λ x . x . {hole_0} |
330++--------------------------------+
332+The solve tactic completes the proof
337+Here we look at each tactic in turn to see how they affect the proof state.
339+Introduction tactics for binders. The binder types are:
341+- lambda function (intro)
342+- dependent function (forall)
346+A precondition of these tactics is that the focused hole is of the form:
352+that is, that the body of its scope consists directly of a reference to the hole-bound variable. If a hole binder were of the form:
354++--------------------+
355+| ?h : t1 -> t2.f h |
356++--------------------+
364+were applied, the result would be the term
366++---------------------------+
367+| ?h : t2 . λ x:t1. f h |
368++---------------------------+
370+However this would cause the application of f to be ill-typed, as it expects an argument of type t1->t2, not an argument of type t2. Additionally, some binding tactics require that t, the type of the hole h, have a specific form, because the binder to be established may have a typing rule associated with it.
372+.. list-table:: Binders
377+ - Introduce a lambda binding around the current hole and focus on the body.
379+ Requires that the hole be in binding form (use 'attack' if it might not be).
381+ @ n the name to use for the argument.
385+ intro : (n : TTName) -> Elab ()
392+ - Introduce a lambda binding around the current hole and focus on the body, using the name provided by the type of the hole.
394+ Requires that the hole be immediately under its binder (use 'attack' if it might not be).
401+ - Introduce a dependent function type binding into the current hole, and focus on the body. Requires that the hole be immediately under its binder
403+ (use 'attack' if it might not be).
407+ forall : TTName -> Raw -> Elab ()
410+ - Introduce a new pattern binding. Requires that the hole be immediately under its binder (use 'attack' if it might not be).
414+ patbind : TTName -> Elab ()
417+ - Introduce a new let binding.
419+ Requires that the hole be immediately under its binder (use 'attack' if it might not be).
421+ - @ n the name to let bind
422+ - @ ty the type of the term to be let-bound
423+ - @ tm the term to be bound
427+ letbind : (n : TTName) -> (ty, tm : Raw) -> Elab ()
430+.. _`Dependently Typed Functional Programs and their Proofs by McBride 1999`: https://www.era.lib.ed.ac.uk/handle/1842/374
docs/faq/faq.rstnew file+329
@@ -0,0 +1,329 @@
1+**************************
2+Frequently Asked Questions
3+**************************
5+What are the differences between Agda and Idris?
6+================================================
8+Like Idris, Agda is a functional language with dependent types, supporting
9+dependent pattern matching. Both can be used for writing programs and proofs.
10+However, Idris has been designed from the start to emphasise general purpose
11+programming rather than theorem proving. As such, it supports interoperability
12+with systems libraries and C programs, and language constructs for
13+domain specific language implementation. It also includes higher level
14+programming constructs such as interfaces (similar to type classes) and do notation.
16+Idris supports multiple back ends (C and JavaScript by default, with the
17+ability to add more via plugins) and has a reference run time system, written
18+in C, with a garbage collector and built-in message passing concurrency.
21+Is Idris production ready?
22+==========================
24+Idris is primarily a research tool for exploring the possibilities of software
25+development with dependent types, meaning that the primary goal is not (yet) to
26+make a system which could be used in production. As such, there are a few rough
27+corners, and lots of missing libraries. Nobody is working on Idris full time,
28+and we don't have the resources at the moment to polish the system on our own.
29+Therefore, we don't recommend building your business around it!
31+Having said that, contributions which help towards making Idris suitable
32+for use in production would be very welcome - this includes (but is not
33+limited to) extra library support, polishing the run-time system (and ensuring
34+it is robust), providing and maintaining a JVM back end, etc.
36+Is there some documentation for the standard lib? List of functions?
37+=====================================================================
39+API documentation for the shipped packages is listed on `the
40+documentation page <https://www.idris-lang.org/documentation/>`_.
42+Unfortunately, the default prelude and shipped packages for `Idris`
43+are not necessarily complete with regards to documentation. Other
44+ways to find functions include:
48+ + Use `:apropos` to search for text in documentation and function names.
49+ + Use `:search` to search for functions of a given type.
50+ + Use `:browse` to list the contents of a given namespace.
52++ Use the REPL's auto-complete functionality.
53++ Grep through the source code in `libs/`
55+If you find that the shipped packages are lacking in documentation,
56+please feel free to write some. Or bug someone to do so. `Idris` has
57+syntax for providing rich documentation, which is then viewable using
58+the `:doc` command and listed in generated HTML API documentation.
61+Why does Idris use eager evaluation rather than lazy?
62+=====================================================
64+Idris uses eager evaluation for more predictable performance, in particular
65+because one of the longer term goals is to be able to write efficient and
66+verified low level code such as device drivers and network infrastructure.
67+Furthermore, the Idris type system allows us to state precisely the type
68+of each value, and therefore the run-time form of each value. In a lazy
69+language, consider a value of type ``Int``:
75+What is the representation of ``thing`` at run-time? Is it a bit pattern
76+representing an integer, or is it a pointer to some code which will compute
77+an integer? In Idris, we have decided that we would like to make this
78+distinction precise, in the type:
83+ thing_comp : Lazy Int
85+Here, it is clear from the type that ``thing_val`` is guaranteed to be a
86+concrete ``Int``, whereas ``thing_comp`` is a computation which will produce an
90+How can I make lazy control structures?
91+=======================================
93+You can make control structures using the special Lazy type. For
94+example, ``if...then...else...`` in Idris expands to an application of
95+a function named ``ifThenElse``. The default implementation for
96+Booleans is defined as follows in the library:
100+ ifThenElse : Bool -> (t : Lazy a) -> (e : Lazy a) -> a
101+ ifThenElse True t e = t
102+ ifThenElse False t e = e
104+The type ``Lazy a`` for ``t`` and ``e`` indicates that those arguments will
105+only be evaluated if they are used, that is, they are evaluated lazily.
108+Evaluation at the REPL doesn't behave as I expect. What's going on?
109+===================================================================
111+Being a fully dependently typed language, Idris has two phases where it
112+evaluates things, compile-time and run-time. At compile-time it will only
113+evaluate things which it knows to be total (i.e. terminating and covering all
114+possible inputs) in order to keep type checking decidable. The compile-time
115+evaluator is part of the Idris kernel, and is implemented in Haskell using a
116+HOAS (higher order abstract syntax) style representation of values. Since
117+everything is known to have a normal form here, the evaluation strategy doesn't
118+actually matter because either way it will get the same answer, and in practice
119+it will do whatever the Haskell run-time system chooses to do.
121+The REPL, for convenience, uses the compile-time notion of evaluation. As well
122+as being easier to implement (because we have the evaluator available) this can
123+be very useful to show how terms evaluate in the type checker. So you can see
124+the difference between:
126+.. code-block:: idris
128+ Idris> \n, m => (S n) + m
129+ \n => \m => S (plus n m) : Nat -> Nat -> Nat
131+ Idris> \n, m => n + (S m)
132+ \n => \m => plus n (S m) : Nat -> Nat -> Nat
135+Why can't I use a function with no arguments in a type?
136+=======================================================
138+If you use a name in a type which begins with a lower case letter, and which is
139+not applied to any arguments, then Idris will treat it as an implicitly
140+bound argument. For example:
142+.. code-block:: idris
144+ append : Vect n ty -> Vect m ty -> Vect (n + m) ty
146+Here, ``n``, ``m``, and ``ty`` are implicitly bound. This rule applies even
147+if there are functions defined elsewhere with any of these names. For example,
150+.. code-block:: idris
155+Even in this case, ``ty`` is still considered implicitly bound in the definition
156+of ``append``, rather than making the type of ``append`` equivalent to...
158+.. code-block:: idris
160+ append : Vect n String -> Vect m String -> Vect (n + m) String
162+...which is probably not what was intended! The reason for this rule is so
163+that it is clear just from looking at the type of ``append``, and no other
164+context, what the implicitly bound names are.
166+If you want to use an unapplied name in a type, you have two options. You
167+can either explicitly qualify it, for example, if ``ty`` is defined in the
168+namespace ``Main`` you can do the following:
170+.. code-block:: idris
172+ append : Vect n Main.ty -> Vect m Main.ty -> Vect (n + m) Main.ty
174+Alternatively, you can use a name which does not begin with a lower case
175+letter, which will never be implicitly bound:
177+.. code-block:: idris
182+ append : Vect n Ty -> Vect m Ty -> Vect (n + m) Ty
184+As a convention, if a name is intended to be used as a type synonym, it is
185+best for it to begin with a capital letter to avoid this restriction.
188+I have an obviously terminating program, but Idris says it possibly isn't total. Why is that?
189+=============================================================================================
191+Idris can't decide in general whether a program is terminating due to
192+the undecidability of the `Halting Problem
193+<https://en.wikipedia.org/wiki/Halting_problem>`_. It is possible, however,
194+to identify some programs which are definitely terminating. Idris does this
195+using "size change termination" which looks for recursive paths from a
196+function back to itself. On such a path, there must be at least one
197+argument which converges to a base case.
199+- Mutually recursive functions are supported
201+- However, all functions on the path must be fully applied. In particular,
202+ higher order applications are not supported
204+- Idris identifies arguments which converge to a base case by looking for
205+ recursive calls to syntactically smaller arguments of inputs. e.g.
206+ ``k`` is syntactically smaller than ``S (S k)`` because ``k`` is a
207+ subterm of ``S (S k)``, but ``(k, k)`` is
208+ not syntactically smaller than ``(S k, S k)``.
210+If you have a function which you believe to be terminating, but Idris does
211+not, you can either restructure the program, or use the ``assert_total``
215+When will Idris be self-hosting?
216+================================
218+It’s not a priority, though not a bad idea in the long run. It would
219+be a worthwhile effort in the short term to implement libraries in
220+Idris to support self-hosting, such as argument parsing and a
221+POSIX-compliant library for system interaction.
223+Does Idris have universe polymorphism? What is the type of ``Type``?
224+====================================================================
226+Rather than universe polymorphism, Idris has a cumulative hierarchy of
227+universes; ``Type : Type 1``, ``Type 1 : Type 2``, etc.
228+Cumulativity means that if ``x : Type n`` and ``n <= m``, then
229+``x : Type m``. Universe levels are always inferred by Idris, and
230+cannot be specified explicitly. The REPL command ``:type Type 1`` will
231+result in an error, as will attempting to specify the universe level
235+Why does Idris use ``Double`` instead of ``Float64``?
236+=====================================================
238+Historically the C language and many other languages have used the
239+names ``Float`` and ``Double`` to represent floating point numbers of
240+size 32 and 64 respectively. Newer languages such as Rust and Julia
241+have begun to follow the naming scheme described in `IEEE Standard for
242+Floating-Point Arithmetic (IEEE 754)
243+<https://en.wikipedia.org/wiki/IEEE_floating_point>`_. This describes
244+single and double precision numbers as ``Float32`` and ``Float64``;
245+the size is described in the type name.
247+Due to developer familiarity with the older naming convention, and
248+choice by the developers of Idris, Idris uses the C style convention.
249+That is, the name ``Double`` is used to describe double precision
250+numbers, and Idris does not support 32 bit floats at present.
253+What is -ffreestanding?
254+=======================
256+The freestanding flag is used to build Idris binaries which have their
257+libs and compiler in a relative path. This is useful for building binaries
258+where the install directory is unknown at build time. When passing this
259+flag, the IDRIS_LIB_DIR environment variable needs to be set to the path
260+where the Idris libs reside relative to the idris executable. The
261+IDRIS_TOOLCHAIN_DIR environment variable is optional, if that is set,
262+Idris will use that path to find the C compiler. For example:
266+ IDRIS_LIB_DIR="./libs" \
267+ IDRIS_TOOLCHAIN_DIR="./mingw/bin" \
268+ CABALFLAGS="-fffi -ffreestanding -frelease" \
272+What does the name “Idris” mean?
273+================================
275+British people of a certain age may be familiar with this
276+`singing dragon <https://www.youtube.com/watch?v=G5ZMNyscPcg>`_. If
277+that doesn’t help, maybe you can invent a suitable acronym :-) .
280+Will there be support for Unicode characters for operators?
281+===========================================================
283+There are several reasons why we should not support Unicode operators:
285+- It's hard to type (this is important if you're using someone else's code, for
286+ example). Various editors have their own input methods, but you have to know
289+- Not every piece of software easily supports it. Rendering issues have been
290+ noted on some mobile email clients, terminal-based IRC clients, web browsers,
291+ etc. There are ways to resolve these rendering issues but they provide a
292+ barrier to entry to using Idris.
294+- Even if we leave it out of the standard library (which we will in any case!)
295+ as soon as people start using it in their library code, others have to deal
298+- Too many characters look too similar. We had enough trouble with confusion
299+ between 0 and O without worrying about all the different kinds of colons and
302+- There seems to be a tendency to go over the top with use of Unicode. For
303+ example, using sharp and flat for delay and force (or is it the other way
304+ around?) in Agda seems gratuitous. We don't want to encourage this sort of
305+ thing, when words are often better.
307+With care, Unicode operators can make things look pretty but so can ``lhs2TeX``.
308+Perhaps in a few years time things will be different and software will cope
309+better and it will make sense to revisit this. For now, however, Idris will not
310+be offering arbitrary Unicode symbols in operators.
312+This seems like an instance of `Wadler's
313+Law <https://www.haskell.org/haskellwiki/Wadler%27s_Law>`__ in action.
315+This answer is based on Edwin Brady's response in the following
316+`pull request <https://github.com/idris-lang/Idris-dev/pull/694#issuecomment-29559291>`_.
318+Where can I find the community standards for the Idris community?
319+==================================================================
321+The Idris Community Standards are stated `here
322+<https://www.idris-lang.org/documentation/community-standards/>`_ .
324+Where can I find more answers?
325+==============================
327+There is an `Unofficial FAQ
328+<https://github.com/idris-lang/Idris-dev/wiki/Unofficial-FAQ>`_ on the wiki on
329+GitHub which answers more technical questions and may be updated more often.
docs/guides/index.rstnew file+22
@@ -0,0 +1,22 @@
3+################################
4+Tutorials on the Idris Language
5+################################
7+Tutorials submitted by community members.
10+ The documentation for Idris has been published under the Creative
11+ Commons CC0 License. As such to the extent possible under law, *The
12+ Idris Community* has waived all copyright and related or neighboring
13+ rights to Documentation for Idris.
15+ More information concerning the CC0 can be found online at: https://creativecommons.org/publicdomain/zero/1.0/
docs/guides/theorem-prover.rstnew file+217
@@ -0,0 +1,217 @@
1+*******************************
2+The Interactive Theorem Prover
3+*******************************
5+This short guide contributed by a community member illustrates how to prove associativity of addition on ``Nat`` using the interactive theorem prover.
7+First we define a module ``Foo.idr``
13+ plusAssoc : plus n (plus m o) = plus (plus n m) o
16+We wish to perform induction on ``n``. First we load the file into the Idris ``REPL`` as follows::
20+We will be given the following prompt, in future releases the version string will differ::
23+ / _/___/ /____(_)____
24+ / // __ / ___/ / ___/ Version 0.9.18.1
25+ _/ // /_/ / / / (__ ) https://www.idris-lang.org/
26+ /___/\__,_/_/ /_/____/ Type :? for help
28+ Idris is free software with ABSOLUTELY NO WARRANTY.
29+ For details type :warranty.
30+ Type checking ./Foo.idr
31+ Metavariables: Foo.rhs
38+We start the interactive session by asking Idris to prove the
39+hole ``rhs`` using the command ``:p rhs``. Idris by default
40+will show us the initial context. This looks as follows::
43+ ---------- Goal: ----------
48+ plus n (plus m o) = plus (plus n m) o
53+We first apply the ``intros`` tactic::
56+ ---------- Other goals: ----------
60+ ---------- Assumptions: ----------
64+ ---------- Goal: ----------
66+ plus n (plus m o) = plus (plus n m) o
71+Then apply ``induction`` on to ``n``::
73+ -Foo.rhs> induction n
74+ ---------- Other goals: ----------
79+ ---------- Assumptions: ----------
83+ ---------- Goal: ----------
85+ plus Z (plus m o) = plus (plus Z m) o
94+ ---------- Other goals: ----------
99+ ---------- Assumptions: ----------
103+ ---------- Goal: ----------
113+ ---------- Other goals: ----------
117+ ---------- Assumptions: ----------
121+ ---------- Goal: ----------
124+ (plus n__0 (plus m o) = plus (plus n__0 m) o) ->
125+ plus (S n__0) (plus m o) = plus (plus (S n__0) m) o
133+ ---------- Other goals: ----------
139+ ---------- Assumptions: ----------
144+ ihn__0 : plus n__0 (plus m o) = plus (plus n__0 m) o
145+ ---------- Goal: ----------
147+ plus (S n__0) (plus m o) = plus (plus (S n__0) m) o
156+ ---------- Other goals: ----------
162+ ---------- Assumptions: ----------
167+ ihn__0 : plus n__0 (plus m o) = plus (plus n__0 m) o
168+ ---------- Goal: ----------
170+ S (plus n__0 (plus m o)) = S (plus (plus n__0 m) o)
178+ -Foo.rhs> rewrite ihn__0
179+ ---------- Other goals: ----------
186+ ---------- Assumptions: ----------
191+ ihn__0 : plus n__0 (plus m o) = plus (plus n__0 m) o
192+ ---------- Goal: ----------
194+ S (plus n__0 (plus m o)) = S (plus n__0 (plus m o))
215+Two goals were created: one for ``Z`` and one for ``S``.
216+Here we have proven associativity, and assembled a tactic based proof script.
217+This proof script can be added to ``Foo.idr``.
docs/guides/type-providers-ffi.rstnew file+247
@@ -0,0 +1,247 @@
1+***********************
2+Type Providers in Idris
3+***********************
5+`Type providers in Idris
6+<https://www.davidchristiansen.dk/pubs/dependent-type-providers.pdf>`__
7+are simple enough, but there are a few caveats to using them that it
8+would be worthwhile to go through the basic steps. We also go over
9+foreign functions, because these will often be used with type
15+First, let's talk about *why* we might want type providers. There are
16+a number of reasons to use them and there are other examples available
17+around the net, but in this tutorial we'll be using them to port C's
18+``struct stat`` to Idris.
20+Why do we need type providers? Well, Idris's FFI needs to know the
21+types of the things it passes to and from C, but the fields of a
22+``struct stat`` are implementation-dependent types that cannot be
23+relied upon. We don't just want to hard-code these types into our
24+program... so we'll use a type provider to find them at compile time!
29+First, let's go over a basic usage of type providers, because foreign
30+functions can be confusing but it's important to remember that
31+providers themselves are simple.
33+A type provider is simply an IO action that returns a value of this
38+ data Provider a = Provide a | Error String
40+Looks familiar? ``Provider`` is just ``Either a String``, given a
41+slightly more descriptive name.
43+Remember though, type providers we use in our program must be IO
44+actions. Let's write a simple one now:
49+ -- Asks nicely for the user to supply the size of C's size_t type on this
51+ getSizeT : IO (Provider Int)
53+ putStrLn "I'm sorry, I don't know how big size_t is. Can you tell me, in bytes?"
56+ Just sizeTSize => pure (Provide sizeTSize)
57+ Nothing => pure (Error "I'm sorry, I don't understand.")
58+ -- the readInt function is left as an exercise
60+We assume that whoever's compiling the library knows the size of
61+``size_t``, so we'll just ask them! (Don't worry, we'll get it
62+ourselves later.) Then, if their response can be converted to an
63+integer, we present ``Provide sizeTSize`` as the result of our IO
64+action; or if it can't, we signal a failure. (This will then become a
67+Now we can use this IO action as a type provider:
72+ -- to gain access to the IO action we're using as a provider
75+ -- TypeProviders is an extension, so we'll enable it
76+ %language TypeProviders
78+ -- And finally, use the provider!
79+ -- Note that the parentheses are mandatory.
80+ %provide (sizeTSize : Int) with getSizeT
82+ -- From now on it's just a normal program where `sizeTSize` is available
83+ -- as a top-level constant
86+ putStr "Look! I figured out how big size_t is! It's "
87+ putStr (show sizeTSize)
90+Yay! We... asked the user something at compile time? That's not very
91+good, actually. Our library is going to be difficult to compile! This
92+is hardly a step up from having them edit in the size of ``size_t``
95+Don't worry, there's a better way.
100+It's actually pretty easy to write a C function that figures out the
105+ int sizeof_size_t() { return sizeof(size_t); }
107+(Why an int and not a ``size_t``? The FFI needs to know how to receive
108+the return value of this function and translate it into an Idris
109+value. If we knew how to do this for values of C type ``size_t``, we
110+wouldn't need to write this function at all! If we really wanted to be
111+safe from overflow, we could use an array of multiple integers, but
112+the SIZE of ``size_t`` is never going to be a 65535 byte integer.)
114+So now we can get the size of ``size_t`` as long as we're in C code.
115+We'd like to be able to use this from Idris. Can we do this? It turns
121+With foreign, we can turn a C function into an IO action. It works
124+.. code-block:: idris
127+ getSizeT = foreign FFI_C "sizeof_size_t" (IO Int)
129+Pretty simple. ``foreign`` takes a specification of what function it
130+needs to call and that function's return type.
132+Running foreign functions
133+-------------------------
135+This is all well and good for writing code that will typecheck. To
136+actually run the code, we'll need to do just a bit more work. Exactly
137+what we need to do depends on whether we want to interpret or compile
143+If we want to call our foreign functions from interpreted code (such
144+as the REPL or a type provider), we need to dynamically link a library
145+containing the symbols we need. This is pretty easy to do with the
146+``%dynamic`` directive:
148+.. code-block:: idris
150+ %dynamic "./filename.so"
152+Note that the leading "./" is important: currently, the string you
153+provide is interpreted as by ``dlopen()``, which on Unix does not search
154+in the current directory by default. If you use the "./", the library
155+will be searched for in the directory from which you run idris (*not*
156+the location of the file you're running!). Of course, if you're using
157+functions from an installed library rather than something you wrote
158+yourself, the "./" is not necessary.
163+If we want to run our code from an executable, we can statically link
164+instead. We'll use the ``%include`` and ``%link`` directives:
166+.. code-block:: idris
168+ %include C "filename.h"
169+ %link C "filename.o"
171+Note the extra argument to the directive! We specify that we're
172+linking a C header and library. Also, unlike ``%dynamic``, these
173+directives search in the current directory by default. (That is, the
174+directory from which we run idris.)
176+Putting it all together
177+=======================
179+So, at the beginning of this article I said we'd use type providers to
180+port ``struct stat`` to Idris. The relevant part is just translating
181+all the mysterious typedef'd C types into Idris types, and that's what
184+First, let's write a C file containing functions that we'll bind to.
189+ #include <sys/stat.h>
191+ int sizeof_dev_t() { return sizeof(dev_t); }
192+ int sizeof_ino_t() { return sizeof(ino_t); }
193+ /* lots more functions like this */
195+Next, an Idris file to define our providers:
197+.. code-block:: idris
202+ %dynamic "./stattypes.so"
206+ sizeOfDevT = foreign FFI_C "sizeof_dev_t" (IO Int)
207+ {- lots of similar functions -}
209+ -- Indicates how many bits are used to represent various system
212+ data BitWidth = B8 | B16 | B32 | B64
216+ show B16 = "16 bits"
217+ show B32 = "32 bits"
218+ show B64 = "64 bits"
220+ -- Now we have an integer, but we want a Provider BitWidth.
221+ -- Since our sizeOf* functions are ordinary IO actions, we
222+ -- can just map over them.
223+ bytesToType : Int -> Provider BitWidth
224+ bytesToType 1 = Provide B8 -- "8 bit value"
225+ bytesToType 2 = Provide B16
226+ bytesToType 4 = Provide B32
227+ bytesToType 8 = Provide B64
228+ bytesToType _ = Error "Unrecognised integral type."
230+ getDevT : IO (Provider BitWidth)
231+ getDevT = map bytesToType sizeOfDevT
232+ {- lots of similar functions -}
234+Finally, we'll write one more idris file where we use the type
237+.. code-block:: idris
242+ %language TypeProviders
243+ %provide (DevTBitWidth : BitWidth) with getDevT
245+ -- We can now use DevTBitWidth in our program!
247+ main = putStrLn $ "size of dev_t: " ++ show DevTBitWidth
docs/image/README.mdnew file+16
@@ -0,0 +1,16 @@
1+Many of the images in this directory have two files with the same name but a different extension:
3+* The SVG file, being vector graphics, is best for drawing and modifying.
4+* The PNG file, being raster graphics, gives more consistent rendering.
6+The image has therefore been generated as an SVG file and then exported to the PNG file.
8+So, if you need to modify an image, I suggest the following sequence:
10+* Edit the SVG file using a suitable editor (I use Inkscape).
11+* Export the changes to the PNG file, overwriting the old version.
14+Note, when exporting in Inkscape:
15+* Select everything first, this stops an enormous boundary being exported.
16+* After selecting the file to export to and clicking OK, don't forget to click on export button as well.
docs/image/attack.pngnew file
Binary file not shown.
docs/image/attack.svgnew file+199
@@ -0,0 +1,199 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 210 297"
17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"
18+ sodipodi:docname="attack.svg">
22+ inkscape:stockid="Arrow1Mend"
27+ style="overflow:visible;"
28+ inkscape:isstock="true">
31+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
32+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
33+ transform="scale(0.4) rotate(180) translate(10,0)" />
36+ inkscape:isstock="true"
37+ style="overflow:visible;"
42+ inkscape:stockid="Arrow1Mend"
43+ inkscape:collect="always">
45+ transform="scale(0.4) rotate(180) translate(10,0)"
46+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
47+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
51+ inkscape:stockid="Arrow1Mend"
56+ style="overflow:visible;"
57+ inkscape:isstock="true"
58+ inkscape:collect="always">
61+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
62+ style="fill-rule:evenodd;stroke:#ff0000;stroke-width:1pt;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
63+ transform="scale(0.4) rotate(180) translate(10,0)" />
69+ bordercolor="#666666"
71+ inkscape:pageopacity="0.0"
72+ inkscape:pageshadow="2"
76+ inkscape:document-units="mm"
77+ inkscape:current-layer="layer1"
79+ inkscape:window-width="1920"
80+ inkscape:window-height="1015"
81+ inkscape:window-x="0"
82+ inkscape:window-y="0"
83+ inkscape:window-maximized="1" />
89+ <dc:format>image/svg+xml</dc:format>
91+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
97+ inkscape:label="Layer 1"
98+ inkscape:groupmode="layer"
101+ style="fill:#ffff00;fill-opacity:1;stroke-width:0.26458332"
107+ inkscape:export-xdpi="61.120499"
108+ inkscape:export-ydpi="61.120499" />
110+ xml:space="preserve"
111+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
115+ inkscape:export-xdpi="61.120499"
116+ inkscape:export-ydpi="61.120499"><tspan
117+ sodipodi:role="line"
120+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
121+ id="tspan847">?h ∶ t1→t2 . f h</tspan></text>
126+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
127+ xml:space="preserve"
128+ inkscape:export-xdpi="61.120499"
129+ inkscape:export-ydpi="61.120499"><tspan
130+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
134+ sodipodi:role="line">?h ≈ (?h' ∶ t1→t2 . h')∶ t1→t2 . f h</tspan></text>
139+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
140+ xml:space="preserve"
141+ inkscape:export-xdpi="61.120499"
142+ inkscape:export-ydpi="61.120499"><tspan
143+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332"
147+ sodipodi:role="line">attack</tspan></text>
149+ style="fill:none;stroke:#ff0000;stroke-width:0.5291667;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Mend)"
150+ d="m 80.668481,106.30075 -0.0032,7.57492"
152+ inkscape:connector-curvature="0"
153+ sodipodi:nodetypes="cc"
154+ inkscape:export-xdpi="61.120499"
155+ inkscape:export-ydpi="61.120499" />
157+ inkscape:export-ydpi="61.120499"
158+ inkscape:export-xdpi="61.120499"
159+ xml:space="preserve"
160+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
164+ sodipodi:role="line"
168+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332">focus</tspan></text>
170+ inkscape:export-ydpi="61.120499"
171+ inkscape:export-xdpi="61.120499"
172+ sodipodi:nodetypes="cc"
173+ inkscape:connector-curvature="0"
175+ d="m 66.645564,94.659084 -0.0032,5.458256"
176+ style="fill:none;stroke:#0000ff;stroke-width:0.5291667;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker838)" />
181+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
182+ xml:space="preserve"
183+ inkscape:export-xdpi="61.120499"
184+ inkscape:export-ydpi="61.120499"><tspan
185+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332"
189+ sodipodi:role="line">focus</tspan></text>
191+ style="fill:none;stroke:#0000ff;stroke-width:0.5291667;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker890)"
192+ d="m 66.67818,108.97924 -0.0032,5.45826"
194+ inkscape:connector-curvature="0"
195+ sodipodi:nodetypes="cc"
196+ inkscape:export-xdpi="61.120499"
197+ inkscape:export-ydpi="61.120499" />
docs/image/binders.pngnew file
Binary file not shown.
docs/image/binders.svgnew file+326
@@ -0,0 +1,326 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="binders.svg">
24+ bordercolor="#666666"
26+ inkscape:pageopacity="0.0"
27+ inkscape:pageshadow="2"
29+ inkscape:cx="255.00889"
31+ inkscape:document-units="px"
32+ inkscape:current-layer="layer1"
34+ inkscape:window-width="1163"
35+ inkscape:window-height="1011"
36+ inkscape:window-x="-4"
37+ inkscape:window-y="0"
38+ inkscape:window-maximized="0" />
44+ <dc:format>image/svg+xml</dc:format>
46+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
47+ <dc:title></dc:title>
52+ inkscape:label="Layer 1"
53+ inkscape:groupmode="layer"
57+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
61+ sodipodi:linespacing="125%"
62+ inkscape:export-xdpi="61.120499"
63+ inkscape:export-ydpi="61.120499"><tspan
68+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;">Code</tspan></text>
70+ sodipodi:linespacing="125%"
74+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
76+ inkscape:export-xdpi="61.120499"
77+ inkscape:export-ydpi="61.120499"><tspan
78+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;"
82+ sodipodi:role="line">Logic</tspan></text>
84+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
85+ d="m 229,161.3622 1,298"
87+ inkscape:connector-curvature="0"
88+ sodipodi:nodetypes="cc"
89+ inkscape:export-xdpi="61.120499"
90+ inkscape:export-ydpi="61.120499" />
92+ inkscape:connector-curvature="0"
94+ d="m 473.5,184.8622 -364,1"
95+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
96+ sodipodi:nodetypes="cc"
97+ inkscape:export-xdpi="61.120499"
98+ inkscape:export-ydpi="61.120499" />
100+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
101+ d="m 473.5,270.8622 -364,1"
103+ inkscape:connector-curvature="0"
104+ sodipodi:nodetypes="cc"
105+ inkscape:export-xdpi="61.120499"
106+ inkscape:export-ydpi="61.120499" />
108+ inkscape:connector-curvature="0"
110+ d="m 475.5,362.8622 -366,1"
111+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
112+ sodipodi:nodetypes="cc"
113+ inkscape:export-xdpi="61.120499"
114+ inkscape:export-ydpi="61.120499" />
116+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
117+ d="m 475.5,458.8622 -366,1"
119+ inkscape:connector-curvature="0"
120+ sodipodi:nodetypes="cc"
121+ inkscape:export-xdpi="61.120499"
122+ inkscape:export-ydpi="61.120499" />
124+ sodipodi:linespacing="125%"
128+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
129+ xml:space="preserve"
130+ inkscape:export-xdpi="61.120499"
131+ inkscape:export-ydpi="61.120499"><tspan
132+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
136+ sodipodi:role="line">Abstraction</tspan></text>
138+ xml:space="preserve"
139+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
143+ sodipodi:linespacing="125%"
144+ inkscape:export-xdpi="61.120499"
145+ inkscape:export-ydpi="61.120499"><tspan
146+ sodipodi:role="line"
150+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">let</tspan><tspan
151+ sodipodi:role="line"
154+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
155+ id="tspan4184">binding</tspan></text>
157+ sodipodi:linespacing="125%"
161+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
162+ xml:space="preserve"
163+ inkscape:export-xdpi="61.120499"
164+ inkscape:export-ydpi="61.120499"><tspan
165+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
169+ sodipodi:role="line">function</tspan><tspan
170+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
173+ sodipodi:role="line"
174+ id="tspan4166">space</tspan></text>
176+ xml:space="preserve"
177+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
181+ sodipodi:linespacing="125%"
182+ inkscape:export-xdpi="61.120499"
183+ inkscape:export-ydpi="61.120499"><tspan
184+ sodipodi:role="line"
188+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;">λ x:t</tspan></text>
190+ sodipodi:linespacing="125%"
194+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
195+ xml:space="preserve"
196+ inkscape:export-xdpi="61.120499"
197+ inkscape:export-ydpi="61.120499"><tspan
198+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;"
202+ sodipodi:role="line">Γ ⊢ S : Type</tspan></text>
204+ sodipodi:linespacing="125%"
208+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
209+ xml:space="preserve"
210+ inkscape:export-xdpi="61.120499"
211+ inkscape:export-ydpi="61.120499"><tspan
212+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;"
216+ sodipodi:role="line">let x ↦ t : t</tspan></text>
218+ inkscape:connector-curvature="0"
220+ d="m 383.5,227.8622 -136,1"
221+ style="fill:none;fill-rule:evenodd;stroke:#0000ff;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
222+ sodipodi:nodetypes="cc"
223+ inkscape:export-xdpi="61.120499"
224+ inkscape:export-ydpi="61.120499" />
226+ xml:space="preserve"
227+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
231+ sodipodi:linespacing="125%"
232+ inkscape:export-xdpi="61.120499"
233+ inkscape:export-ydpi="61.120499"><tspan
234+ sodipodi:role="line"
238+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;">Γ ; λ x:S ⊢ valid</tspan></text>
240+ xml:space="preserve"
241+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
245+ sodipodi:linespacing="125%"
246+ inkscape:export-xdpi="61.120499"
247+ inkscape:export-ydpi="61.120499"><tspan
248+ sodipodi:role="line"
252+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;">Γ ⊢ S : Type</tspan></text>
254+ sodipodi:nodetypes="cc"
255+ style="fill:none;fill-rule:evenodd;stroke:#0000ff;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
256+ d="m 381.5,313.8622 -136,1"
258+ inkscape:connector-curvature="0"
259+ inkscape:export-xdpi="61.120499"
260+ inkscape:export-ydpi="61.120499" />
262+ sodipodi:linespacing="125%"
266+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
267+ xml:space="preserve"
268+ inkscape:export-xdpi="61.120499"
269+ inkscape:export-ydpi="61.120499"><tspan
270+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;"
274+ sodipodi:role="line">Γ ; ∀ x:S ⊢ valid</tspan></text>
276+ xml:space="preserve"
277+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
281+ sodipodi:linespacing="125%"
282+ inkscape:export-xdpi="61.120499"
283+ inkscape:export-ydpi="61.120499"><tspan
284+ sodipodi:role="line"
288+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;">∀ x:t</tspan></text>
290+ sodipodi:linespacing="125%"
294+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
295+ xml:space="preserve"
296+ inkscape:export-xdpi="61.120499"
297+ inkscape:export-ydpi="61.120499"><tspan
298+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;"
302+ sodipodi:role="line">Γ ⊢ S : Type Γ ⊢ s:S </tspan></text>
304+ inkscape:connector-curvature="0"
306+ d="m 453.5,407.8622 -210,1"
307+ style="fill:none;fill-rule:evenodd;stroke:#0000ff;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
308+ sodipodi:nodetypes="cc"
309+ inkscape:export-xdpi="61.120499"
310+ inkscape:export-ydpi="61.120499" />
312+ xml:space="preserve"
313+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
317+ sodipodi:linespacing="125%"
318+ inkscape:export-xdpi="61.120499"
319+ inkscape:export-ydpi="61.120499"><tspan
320+ sodipodi:role="line"
324+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;">Γ ; let x ↦ s : S ⊢ valid</tspan></text>
docs/image/compareToProofAssist.pngnew file
Binary file not shown.
docs/image/compareToProofAssist.svgnew file+260
@@ -0,0 +1,260 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="compareToProofAssist.svg">
22+ inkscape:isstock="true"
23+ style="overflow:visible;"
28+ inkscape:stockid="Arrow1Mend">
30+ transform="scale(0.4) rotate(180) translate(10,0)"
31+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
32+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
36+ inkscape:stockid="Arrow1Mend"
41+ style="overflow:visible;"
42+ inkscape:isstock="true">
45+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
46+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
47+ transform="scale(0.4) rotate(180) translate(10,0)" />
50+ inkscape:isstock="true"
51+ style="overflow:visible;"
56+ inkscape:stockid="Arrow1Mend"
57+ inkscape:collect="always">
59+ transform="scale(0.4) rotate(180) translate(10,0)"
60+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
61+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
65+ inkscape:stockid="Arrow1Mend"
70+ style="overflow:visible;"
71+ inkscape:isstock="true"
72+ inkscape:collect="always">
75+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
76+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
77+ transform="scale(0.4) rotate(180) translate(10,0)" />
83+ bordercolor="#666666"
85+ inkscape:pageopacity="0.0"
86+ inkscape:pageshadow="2"
88+ inkscape:cx="377.89372"
90+ inkscape:document-units="px"
91+ inkscape:current-layer="layer1"
93+ inkscape:window-width="1920"
94+ inkscape:window-height="1015"
95+ inkscape:window-x="0"
96+ inkscape:window-y="0"
97+ inkscape:window-maximized="1" />
103+ <dc:format>image/svg+xml</dc:format>
105+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
111+ inkscape:label="Layer 1"
112+ inkscape:groupmode="layer"
115+ xml:space="preserve"
116+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
120+ sodipodi:linespacing="125%"
121+ inkscape:export-xdpi="61.120499"
122+ inkscape:export-ydpi="61.120499"><tspan
123+ sodipodi:role="line"
127+ style="font-size:15px;-inkscape-font-specification:'sans-serif Bold';font-family:sans-serif;font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal">Human</tspan></text>
129+ sodipodi:linespacing="125%"
133+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
134+ xml:space="preserve"
135+ inkscape:export-xdpi="61.120499"
136+ inkscape:export-ydpi="61.120499"><tspan
137+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
141+ sodipodi:role="line">Tactics</tspan></text>
143+ xml:space="preserve"
144+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
148+ sodipodi:linespacing="125%"
149+ inkscape:export-xdpi="61.120499"
150+ inkscape:export-ydpi="61.120499"><tspan
151+ sodipodi:role="line"
155+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">fill holes</tspan></text>
157+ sodipodi:linespacing="125%"
161+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
162+ xml:space="preserve"
163+ inkscape:export-xdpi="61.120499"
164+ inkscape:export-ydpi="61.120499"><tspan
165+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;"
169+ sodipodi:role="line">Proof assistant</tspan></text>
171+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Mend)"
172+ d="m 188,329.3622 0,22"
174+ inkscape:connector-curvature="0"
175+ inkscape:export-xdpi="61.120499"
176+ inkscape:export-ydpi="61.120499" />
178+ inkscape:connector-curvature="0"
180+ d="m 187,373.3622 0,22"
181+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4436)"
182+ inkscape:export-xdpi="61.120499"
183+ inkscape:export-ydpi="61.120499" />
185+ xml:space="preserve"
186+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
190+ sodipodi:linespacing="125%"
191+ inkscape:export-xdpi="61.120499"
192+ inkscape:export-ydpi="61.120499"><tspan
193+ sodipodi:role="line"
197+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">Idris source</tspan></text>
199+ sodipodi:linespacing="125%"
203+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
204+ xml:space="preserve"
205+ inkscape:export-xdpi="61.120499"
206+ inkscape:export-ydpi="61.120499"><tspan
207+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
211+ sodipodi:role="line">fill holes</tspan><tspan
212+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
215+ sodipodi:role="line"
216+ id="tspan5060">(implicit variables, etc)</tspan></text>
218+ xml:space="preserve"
219+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
223+ sodipodi:linespacing="125%"
224+ inkscape:export-xdpi="61.120499"
225+ inkscape:export-ydpi="61.120499"><tspan
226+ sodipodi:role="line"
230+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000">Idris Elaborator</tspan></text>
232+ inkscape:connector-curvature="0"
234+ d="m 342,330.3622 0,22"
235+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4251)"
236+ inkscape:export-xdpi="61.120499"
237+ inkscape:export-ydpi="61.120499" />
239+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker5018)"
240+ d="m 341,374.3622 0,22"
242+ inkscape:connector-curvature="0"
243+ inkscape:export-xdpi="61.120499"
244+ inkscape:export-ydpi="61.120499" />
246+ inkscape:export-ydpi="61.120499"
247+ inkscape:export-xdpi="61.120499"
248+ sodipodi:linespacing="125%"
252+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
253+ xml:space="preserve"><tspan
254+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
258+ sodipodi:role="line">Tactics</tspan></text>
docs/image/effects-tree.pngnew file
Binary file not shown.
docs/image/elab.pngnew file
Binary file not shown.
docs/image/elab.svgnew file+139
@@ -0,0 +1,139 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="elab.svg">
22+ inkscape:stockid="Arrow1Mend"
27+ style="overflow:visible;"
28+ inkscape:isstock="true">
31+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
32+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
33+ transform="scale(0.4) rotate(180) translate(10,0)" />
39+ bordercolor="#666666"
41+ inkscape:pageopacity="0.0"
42+ inkscape:pageshadow="2"
44+ inkscape:cx="381.03373"
46+ inkscape:document-units="px"
47+ inkscape:current-layer="layer1"
49+ inkscape:window-width="1072"
50+ inkscape:window-height="1011"
51+ inkscape:window-x="-4"
52+ inkscape:window-y="0"
53+ inkscape:window-maximized="0" />
59+ <dc:format>image/svg+xml</dc:format>
61+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
62+ <dc:title></dc:title>
67+ inkscape:label="Layer 1"
68+ inkscape:groupmode="layer"
71+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
77+ inkscape:export-xdpi="61.120499"
78+ inkscape:export-ydpi="61.120499" />
85+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
86+ inkscape:export-xdpi="61.120499"
87+ inkscape:export-ydpi="61.120499" />
89+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Mend)"
90+ d="m 328,331.3622 19,55"
92+ inkscape:connector-curvature="0"
93+ sodipodi:nodetypes="cc"
94+ inkscape:export-xdpi="61.120499"
95+ inkscape:export-ydpi="61.120499" />
98+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
102+ sodipodi:linespacing="125%"
103+ inkscape:export-xdpi="61.120499"
104+ inkscape:export-ydpi="61.120499"><tspan
105+ sodipodi:role="line"
109+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">Definition Elaborator</tspan></text>
111+ sodipodi:linespacing="125%"
115+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
116+ xml:space="preserve"
117+ inkscape:export-xdpi="61.120499"
118+ inkscape:export-ydpi="61.120499"><tspan
119+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
123+ sodipodi:role="line">definition context</tspan></text>
125+ xml:space="preserve"
126+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
130+ sodipodi:linespacing="125%"
131+ inkscape:export-xdpi="61.120499"
132+ inkscape:export-ydpi="61.120499"><tspan
133+ sodipodi:role="line"
137+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">Term Elaborator</tspan></text>
docs/image/elabLogicEx1_1.pngnew file
Binary file not shown.
docs/image/elabLogicEx1_1.svgnew file+99
@@ -0,0 +1,99 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"
18+ sodipodi:docname="elabLogicEx1_1.svg"
19+ inkscape:export-filename="/home/mjb/Idris-dev/docs/image/elabLogicEx1_1.png"
20+ inkscape:export-xdpi="61.120499"
21+ inkscape:export-ydpi="61.120499">
27+ bordercolor="#666666"
29+ inkscape:pageopacity="0.0"
30+ inkscape:pageshadow="2"
32+ inkscape:cx="97.25613"
33+ inkscape:cy="593.17666"
34+ inkscape:document-units="px"
35+ inkscape:current-layer="layer1"
37+ inkscape:window-width="1920"
38+ inkscape:window-height="1015"
39+ inkscape:window-x="0"
40+ inkscape:window-y="0"
41+ inkscape:window-maximized="1" />
47+ <dc:format>image/svg+xml</dc:format>
49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
55+ inkscape:label="Layer 1"
56+ inkscape:groupmode="layer"
62+ style="font-style:normal;font-weight:normal;line-height:0%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
64+ inkscape:export-xdpi="61.120499"
65+ inkscape:export-ydpi="61.120499"><tspan
66+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
70+ id="tspan4812">hole_2 : pi_arg : Nat -> Nat</tspan></text>
72+ inkscape:export-ydpi="61.120499"
73+ inkscape:export-xdpi="61.120499"
75+ style="font-style:normal;font-weight:normal;line-height:0%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
83+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">hole_0 : pi_arg : Nat -> Nat</tspan></text>
85+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
86+ d="m 423.125,456.2372 185,-1"
88+ inkscape:connector-curvature="0"
89+ inkscape:export-xdpi="61.120499"
90+ inkscape:export-ydpi="61.120499" />
92+ inkscape:connector-curvature="0"
94+ d="m 200,456.3622 185,-1"
95+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
96+ inkscape:export-xdpi="61.120499"
97+ inkscape:export-ydpi="61.120499" />
docs/image/elabLogicEx1_2.pngnew file
Binary file not shown.
docs/image/elabLogicEx1_2.svgnew file+112
@@ -0,0 +1,112 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"
18+ sodipodi:docname="elabLogicEx1_2.svg"
19+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/elabLogicEx1_1.png"
20+ inkscape:export-xdpi="61.120499"
21+ inkscape:export-ydpi="61.120499">
27+ bordercolor="#666666"
29+ inkscape:pageopacity="0.0"
30+ inkscape:pageshadow="2"
32+ inkscape:cx="425.25613"
33+ inkscape:cy="593.17666"
34+ inkscape:document-units="px"
35+ inkscape:current-layer="layer1"
37+ inkscape:window-width="1920"
38+ inkscape:window-height="1015"
39+ inkscape:window-x="0"
40+ inkscape:window-y="0"
41+ inkscape:window-maximized="1" />
47+ <dc:format>image/svg+xml</dc:format>
49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
55+ inkscape:label="Layer 1"
56+ inkscape:groupmode="layer"
62+ style="font-style:normal;font-weight:normal;line-height:0%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
64+ inkscape:export-xdpi="61.120499"
65+ inkscape:export-ydpi="61.120499"><tspan
66+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
70+ id="tspan4812">hole_2 : Nat</tspan></text>
72+ inkscape:export-ydpi="61.120499"
73+ inkscape:export-xdpi="61.120499"
75+ style="font-style:normal;font-weight:normal;line-height:0%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
83+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">hole_0 : (pi_arg : Nat) -> Nat</tspan></text>
85+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
86+ d="m 417.5,456.2372 185,-1"
88+ inkscape:connector-curvature="0"
89+ inkscape:export-xdpi="61.120499"
90+ inkscape:export-ydpi="61.120499" />
92+ inkscape:connector-curvature="0"
94+ d="m 200,456.3622 185,-1"
95+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
96+ inkscape:export-xdpi="61.120499"
97+ inkscape:export-ydpi="61.120499" />
99+ inkscape:export-ydpi="61.120499"
100+ inkscape:export-xdpi="61.120499"
101+ xml:space="preserve"
102+ style="font-style:normal;font-weight:normal;line-height:0%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
105+ id="text4147"><tspan
107+ sodipodi:role="line"
110+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">x : Nat</tspan></text>
docs/image/elabLogicEx1_3.pngnew file
Binary file not shown.
docs/image/elabLogicEx1_3.svgnew file+112
@@ -0,0 +1,112 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"
18+ sodipodi:docname="elabLogicEx1_3.svg"
19+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/elabLogicEx1_1.png"
20+ inkscape:export-xdpi="61.120499"
21+ inkscape:export-ydpi="61.120499">
27+ bordercolor="#666666"
29+ inkscape:pageopacity="0.0"
30+ inkscape:pageshadow="2"
32+ inkscape:cx="425.25613"
33+ inkscape:cy="593.17666"
34+ inkscape:document-units="px"
35+ inkscape:current-layer="layer1"
37+ inkscape:window-width="1920"
38+ inkscape:window-height="1015"
39+ inkscape:window-x="0"
40+ inkscape:window-y="0"
41+ inkscape:window-maximized="1" />
47+ <dc:format>image/svg+xml</dc:format>
49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
55+ inkscape:label="Layer 1"
56+ inkscape:groupmode="layer"
62+ style="font-style:normal;font-weight:normal;line-height:0%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
64+ inkscape:export-xdpi="61.120499"
65+ inkscape:export-ydpi="61.120499"><tspan
66+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
70+ id="tspan4812">hole_2 : Nat</tspan></text>
72+ inkscape:export-ydpi="61.120499"
73+ inkscape:export-xdpi="61.120499"
75+ style="font-style:normal;font-weight:normal;line-height:0%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
83+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">hole_0 : (pi_arg : Nat) -> Nat</tspan></text>
85+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
86+ d="m 434.375,456.2372 185,-1"
88+ inkscape:connector-curvature="0"
89+ inkscape:export-xdpi="61.120499"
90+ inkscape:export-ydpi="61.120499" />
92+ inkscape:connector-curvature="0"
94+ d="m 200,456.3622 185,-1"
95+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
96+ inkscape:export-xdpi="61.120499"
97+ inkscape:export-ydpi="61.120499" />
99+ inkscape:export-ydpi="61.120499"
100+ inkscape:export-xdpi="61.120499"
101+ xml:space="preserve"
102+ style="font-style:normal;font-weight:normal;line-height:0%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
105+ id="text4147"><tspan
107+ sodipodi:role="line"
110+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">x : Nat</tspan></text>
docs/image/elabLogicEx1_4.pngnew file
Binary file not shown.
docs/image/elabLogicEx1_4.svgnew file+80
@@ -0,0 +1,80 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="elabLogicEx1_4.svg"
19+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/elabLogicEx1_1.png"
20+ inkscape:export-xdpi="61.120499"
21+ inkscape:export-ydpi="61.120499">
27+ bordercolor="#666666"
29+ inkscape:pageopacity="0.0"
30+ inkscape:pageshadow="2"
32+ inkscape:cx="425.25613"
33+ inkscape:cy="593.17666"
34+ inkscape:document-units="px"
35+ inkscape:current-layer="layer1"
37+ inkscape:window-width="1157"
38+ inkscape:window-height="1011"
39+ inkscape:window-x="-4"
40+ inkscape:window-y="0"
41+ inkscape:window-maximized="0" />
47+ <dc:format>image/svg+xml</dc:format>
49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
55+ inkscape:label="Layer 1"
56+ inkscape:groupmode="layer"
59+ inkscape:export-ydpi="61.120499"
60+ inkscape:export-xdpi="61.120499"
62+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
66+ sodipodi:linespacing="125%"><tspan
71+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">hole_0 : (pi_arg : Nat) -> Nat</tspan></text>
73+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
74+ d="m 200,484.3622 185,-1"
76+ inkscape:connector-curvature="0"
77+ inkscape:export-xdpi="61.120499"
78+ inkscape:export-ydpi="61.120499" />
docs/image/elabOverview.pngnew file
Binary file not shown.
docs/image/elabOverview.svgnew file+585
@@ -0,0 +1,585 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="elabOverview.svg"
19+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/data.png"
20+ inkscape:export-xdpi="61.120499"
21+ inkscape:export-ydpi="61.120499">
25+ inkscape:stockid="Arrow1Mend"
30+ style="overflow:visible;"
31+ inkscape:isstock="true">
34+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
35+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
36+ transform="scale(0.4) rotate(180) translate(10,0)" />
39+ inkscape:stockid="Arrow1Mend"
44+ style="overflow:visible;"
45+ inkscape:isstock="true">
48+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
49+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
50+ transform="scale(0.4) rotate(180) translate(10,0)" />
53+ inkscape:stockid="Arrow1Mend"
58+ style="overflow:visible;"
59+ inkscape:isstock="true">
62+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
63+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
64+ transform="scale(0.4) rotate(180) translate(10,0)" />
67+ inkscape:stockid="Arrow1Mend"
72+ style="overflow:visible"
73+ inkscape:isstock="true">
75+ inkscape:connector-curvature="0"
77+ d="M 0,0 5,-5 -12.5,0 5,5 0,0 Z"
78+ style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1"
79+ transform="matrix(-0.4,0,0,-0.4,-4,0)" />
85+ bordercolor="#666666"
87+ inkscape:pageopacity="0.0"
88+ inkscape:pageshadow="2"
90+ inkscape:cx="258.17464"
91+ inkscape:cy="544.34419"
92+ inkscape:document-units="px"
93+ inkscape:current-layer="layer1"
95+ inkscape:window-width="1920"
96+ inkscape:window-height="1015"
97+ inkscape:window-x="0"
98+ inkscape:window-y="0"
99+ inkscape:window-maximized="1" />
105+ <dc:format>image/svg+xml</dc:format>
107+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
113+ inkscape:label="Layer 1"
114+ inkscape:groupmode="layer"
117+ xml:space="preserve"
118+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
122+ sodipodi:linespacing="125%"
123+ inkscape:export-xdpi="61.120499"
124+ inkscape:export-ydpi="61.120499"><tspan
125+ sodipodi:role="line"
129+ style="font-size:12.5px">data TT : Type where</tspan><tspan
130+ sodipodi:role="line"
134+ style="font-size:12.5px"> P : NameType -> TTName -> TT -> TT</tspan><tspan
135+ sodipodi:role="line"
138+ style="font-size:12.5px"
139+ id="tspan4142"> V : Int -> TT</tspan><tspan
140+ sodipodi:role="line"
143+ style="font-size:12.5px"
144+ id="tspan4144"> Bind : TTName -> Binder TT -> TT -> TT</tspan><tspan
145+ sodipodi:role="line"
148+ style="font-size:12.5px"
149+ id="tspan4146"> App : TT -> TT -> TT</tspan><tspan
150+ sodipodi:role="line"
153+ style="font-size:12.5px"
154+ id="tspan4148"> TConst : Const -> TT</tspan><tspan
155+ sodipodi:role="line"
158+ style="font-size:12.5px"
159+ id="tspan4150"> Erased : TT</tspan><tspan
160+ sodipodi:role="line"
163+ style="font-size:12.5px"
164+ id="tspan4152"> TType : TTUExp -> TT</tspan><tspan
165+ sodipodi:role="line"
168+ style="font-size:12.5px"
169+ id="tspan4154"> UType : Universe -> TT</tspan></text>
171+ sodipodi:linespacing="125%"
175+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
176+ xml:space="preserve"
177+ inkscape:export-xdpi="61.120499"
178+ inkscape:export-ydpi="61.120499"><tspan
180+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
183+ sodipodi:role="line">globally defined variable</tspan><tspan
184+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
187+ sodipodi:role="line"
188+ id="tspan4197"> from name</tspan></text>
190+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
191+ d="m 486,500.3622 19,-14"
193+ inkscape:connector-curvature="0"
194+ inkscape:export-xdpi="61.120499"
195+ inkscape:export-ydpi="61.120499"
196+ sodipodi:nodetypes="cc" />
198+ xml:space="preserve"
199+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
203+ sodipodi:linespacing="125%"
204+ inkscape:export-xdpi="61.120499"
205+ inkscape:export-ydpi="61.120499"><tspan
206+ sodipodi:role="line"
209+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
210+ id="tspan4224">local (de Bruijn) variable</tspan></text>
212+ inkscape:connector-curvature="0"
214+ d="m 351,524.3622 34,-4"
215+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
216+ sodipodi:nodetypes="cc"
217+ inkscape:export-xdpi="61.120499"
218+ inkscape:export-ydpi="61.120499" />
220+ xml:space="preserve"
221+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
225+ sodipodi:linespacing="125%"
226+ inkscape:export-xdpi="61.120499"
227+ inkscape:export-ydpi="61.120499"><tspan
228+ sodipodi:role="line"
231+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
232+ id="tspan4230">any kind of binder</tspan><tspan
233+ sodipodi:role="line"
236+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
237+ id="tspan4234">lambda, let etc.</tspan></text>
239+ inkscape:connector-curvature="0"
241+ d="m 494,538.3622 39,-8"
242+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
243+ inkscape:export-xdpi="61.120499"
244+ inkscape:export-ydpi="61.120499"
245+ sodipodi:nodetypes="cc" />
247+ xml:space="preserve"
248+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
252+ sodipodi:linespacing="125%"
253+ inkscape:export-xdpi="61.120499"
254+ inkscape:export-ydpi="61.120499"><tspan
255+ sodipodi:role="line"
258+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
259+ id="tspan4238">function application</tspan></text>
261+ inkscape:connector-curvature="0"
263+ d="m 392,554.3622 22,-2"
264+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
265+ sodipodi:nodetypes="cc"
266+ inkscape:export-xdpi="61.120499"
267+ inkscape:export-ydpi="61.120499" />
269+ sodipodi:linespacing="125%"
273+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
274+ xml:space="preserve"
275+ inkscape:export-xdpi="61.120499"
276+ inkscape:export-ydpi="61.120499"><tspan
278+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
281+ sodipodi:role="line">intager, char, string, etc.</tspan></text>
283+ sodipodi:nodetypes="cc"
284+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
285+ d="m 396,568.3622 22,-2"
287+ inkscape:connector-curvature="0"
288+ inkscape:export-xdpi="61.120499"
289+ inkscape:export-ydpi="61.120499" />
291+ xml:space="preserve"
292+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
296+ sodipodi:linespacing="125%"
297+ inkscape:export-xdpi="61.120499"
298+ inkscape:export-ydpi="61.120499"><tspan
299+ sodipodi:role="line"
302+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
303+ id="tspan4272">unknown term for erasing types</tspan></text>
305+ inkscape:connector-curvature="0"
307+ d="m 349,585.3622 22,-2"
308+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
309+ sodipodi:nodetypes="cc"
310+ inkscape:export-xdpi="61.120499"
311+ inkscape:export-ydpi="61.120499" />
313+ sodipodi:linespacing="125%"
317+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
318+ xml:space="preserve"
319+ inkscape:export-xdpi="61.120499"
320+ inkscape:export-ydpi="61.120499"><tspan
322+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
325+ sodipodi:role="line">type of types</tspan></text>
327+ sodipodi:nodetypes="cc"
328+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
329+ d="m 404,602.3622 22,-2"
331+ inkscape:connector-curvature="0"
332+ inkscape:export-xdpi="61.120499"
333+ inkscape:export-ydpi="61.120499" />
335+ xml:space="preserve"
336+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
340+ sodipodi:linespacing="125%"
341+ inkscape:export-xdpi="61.120499"
342+ inkscape:export-ydpi="61.120499"><tspan
343+ sodipodi:role="line"
346+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
347+ id="tspan4295">unique universe</tspan></text>
349+ inkscape:connector-curvature="0"
351+ d="m 408,618.3622 22,-2"
352+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
353+ sodipodi:nodetypes="cc"
354+ inkscape:export-xdpi="61.120499"
355+ inkscape:export-ydpi="61.120499" />
357+ sodipodi:linespacing="125%"
361+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
362+ xml:space="preserve"
363+ inkscape:export-xdpi="61.120499"
364+ inkscape:export-ydpi="61.120499"><tspan
366+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff"
369+ sodipodi:role="line">elements of core language</tspan></text>
371+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
377+ inkscape:export-xdpi="61.120499"
378+ inkscape:export-ydpi="61.120499" />
380+ xml:space="preserve"
381+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
385+ sodipodi:linespacing="125%"
386+ inkscape:export-xdpi="61.120499"
387+ inkscape:export-ydpi="61.120499"><tspan
388+ sodipodi:role="line"
392+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">TT</tspan></text>
394+ inkscape:export-ydpi="61.120499"
395+ inkscape:export-xdpi="61.120499"
396+ sodipodi:linespacing="125%"
400+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
401+ xml:space="preserve"><tspan
403+ style="font-size:12.5px"
406+ sodipodi:role="line">env</tspan><tspan
407+ style="font-size:12.5px"
410+ sodipodi:role="line"
411+ id="tspan4454">goal</tspan><tspan
412+ style="font-size:12.5px"
415+ sodipodi:role="line"
416+ id="tspan4456">holes</tspan><tspan
417+ style="font-size:12.5px"
420+ sodipodi:role="line"
421+ id="tspan4458">guess</tspan></text>
423+ inkscape:export-ydpi="61.120499"
424+ inkscape:export-xdpi="61.120499"
425+ xml:space="preserve"
426+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
430+ sodipodi:linespacing="125%"><tspan
432+ sodipodi:role="line"
435+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000">Elab (List (TTName, Binder TT)</tspan><tspan
436+ sodipodi:role="line"
439+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
440+ id="tspan4462">Elab (TTName,TT)</tspan><tspan
441+ sodipodi:role="line"
444+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
445+ id="tspan4464">Elab (List TTName)</tspan><tspan
446+ sodipodi:role="line"
449+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
450+ id="tspan4466">Elab (TT)</tspan></text>
452+ inkscape:export-ydpi="61.120499"
453+ inkscape:export-xdpi="61.120499"
454+ sodipodi:nodetypes="cc"
455+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
456+ d="M 124.13676,260.36509 158,260.3622"
458+ inkscape:connector-curvature="0" />
460+ inkscape:export-ydpi="61.120499"
461+ inkscape:export-xdpi="61.120499"
462+ xml:space="preserve"
463+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
467+ sodipodi:linespacing="125%"><tspan
468+ sodipodi:role="line"
471+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff"
472+ id="tspan4402">state</tspan></text>
474+ inkscape:export-ydpi="61.120499"
475+ inkscape:export-xdpi="61.120499"
481+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
483+ inkscape:export-ydpi="61.120499"
484+ inkscape:export-xdpi="61.120499"
485+ sodipodi:linespacing="125%"
489+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
490+ xml:space="preserve"><tspan
491+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
495+ sodipodi:role="line">Elab Monad</tspan></text>
497+ inkscape:connector-curvature="0"
499+ d="M 124.13676,274.36509 158,274.3622"
500+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
501+ sodipodi:nodetypes="cc"
502+ inkscape:export-xdpi="61.120499"
503+ inkscape:export-ydpi="61.120499" />
505+ inkscape:export-ydpi="61.120499"
506+ inkscape:export-xdpi="61.120499"
507+ sodipodi:nodetypes="cc"
508+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
509+ d="M 128.13676,288.36509 158,288.3622"
511+ inkscape:connector-curvature="0" />
513+ inkscape:connector-curvature="0"
515+ d="M 132.13676,304.36509 158,304.3622"
516+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
517+ sodipodi:nodetypes="cc"
518+ inkscape:export-xdpi="61.120499"
519+ inkscape:export-ydpi="61.120499" />
521+ style="fill:none;fill-rule:evenodd;stroke:#0000ff;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4738)"
522+ d="m 275,272.3622 c 75.17677,4.63671 121.00356,120.13548 126,174"
524+ inkscape:connector-curvature="0"
525+ sodipodi:nodetypes="cc"
526+ inkscape:export-xdpi="61.120499"
527+ inkscape:export-ydpi="61.120499" />
529+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Mend)"
530+ d="m 189,320.3622 c 50.81716,51.06633 -107.1143,53.76268 -56,0"
532+ inkscape:connector-curvature="0"
533+ sodipodi:nodetypes="cc"
534+ inkscape:export-xdpi="61.120499"
535+ inkscape:export-ydpi="61.120499" />
537+ xml:space="preserve"
538+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
542+ sodipodi:linespacing="125%"
543+ inkscape:export-xdpi="61.120499"
544+ inkscape:export-ydpi="61.120499"><tspan
546+ sodipodi:role="line"
549+ style="font-size:12.5px">solve</tspan><tspan
550+ sodipodi:role="line"
553+ style="font-size:12.5px"
554+ id="tspan15220">fill</tspan><tspan
555+ sodipodi:role="line"
558+ style="font-size:12.5px"
559+ id="tspan15222">apply</tspan><tspan
560+ sodipodi:role="line"
563+ style="font-size:12.5px"
564+ id="tspan15224">focus</tspan><tspan
565+ sodipodi:role="line"
568+ style="font-size:12.5px"
569+ id="tspan15226">...</tspan></text>
571+ sodipodi:linespacing="125%"
575+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:40px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
576+ xml:space="preserve"
577+ inkscape:export-xdpi="61.120499"
578+ inkscape:export-ydpi="61.120499"><tspan
580+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff"
583+ sodipodi:role="line">tactics</tspan></text>
docs/image/elabProofState.pngnew file
Binary file not shown.
docs/image/elabProofState.svgnew file+356
@@ -0,0 +1,356 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="elabProofState.svg">
24+ bordercolor="#666666"
26+ inkscape:pageopacity="0.0"
27+ inkscape:pageshadow="2"
29+ inkscape:cx="252.75613"
31+ inkscape:document-units="px"
32+ inkscape:current-layer="layer1"
34+ inkscape:window-width="1920"
35+ inkscape:window-height="1015"
36+ inkscape:window-x="0"
37+ inkscape:window-y="0"
38+ inkscape:window-maximized="1" />
44+ <dc:format>image/svg+xml</dc:format>
46+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
52+ inkscape:label="Layer 1"
53+ inkscape:groupmode="layer"
56+ sodipodi:linespacing="125%"
60+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
62+ inkscape:export-xdpi="61.120499"
63+ inkscape:export-ydpi="61.120499"><tspan
64+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
68+ sodipodi:role="line">current proof</tspan><tspan
69+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
73+ id="tspan4206"> term</tspan></text>
76+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
80+ sodipodi:linespacing="125%"
81+ inkscape:export-xdpi="61.120499"
82+ inkscape:export-ydpi="61.120499"><tspan
87+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">(TTName, TT)</tspan></text>
89+ sodipodi:linespacing="125%"
93+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
95+ inkscape:export-xdpi="61.120499"
96+ inkscape:export-ydpi="61.120499"><tspan
97+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
101+ sodipodi:role="line">original goal</tspan></text>
103+ xml:space="preserve"
104+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
108+ sodipodi:linespacing="125%"
109+ inkscape:export-xdpi="61.120499"
110+ inkscape:export-ydpi="61.120499"><tspan
112+ sodipodi:role="line"
115+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">path</tspan><tspan
116+ sodipodi:role="line"
119+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
120+ id="tspan4216">subterm</tspan><tspan
121+ sodipodi:role="line"
124+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
125+ id="tspan4218">updates</tspan></text>
127+ sodipodi:linespacing="125%"
131+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
132+ xml:space="preserve"
133+ inkscape:export-xdpi="61.120499"
134+ inkscape:export-ydpi="61.120499"><tspan
135+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
138+ sodipodi:role="line"
139+ id="tspan4243">Contexts used for global definitions and for proof state.</tspan><tspan
140+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
143+ sodipodi:role="line"
144+ id="tspan4190">They contain universe constraints and existing definitions.</tspan><tspan
145+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
148+ sodipodi:role="line"
149+ id="tspan4253">Also store maximum RigCount of the namel</tspan></text>
151+ inkscape:export-ydpi="61.120499"
152+ inkscape:export-xdpi="61.120499"
153+ sodipodi:linespacing="125%"
157+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
158+ xml:space="preserve"><tspan
159+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
163+ sodipodi:role="line">Environment</tspan></text>
165+ xml:space="preserve"
166+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
170+ sodipodi:linespacing="125%"
171+ inkscape:export-xdpi="61.120499"
172+ inkscape:export-ydpi="61.120499"><tspan
173+ sodipodi:role="line"
177+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1">Holes</tspan></text>
179+ inkscape:export-ydpi="61.120499"
180+ inkscape:export-xdpi="61.120499"
181+ sodipodi:linespacing="125%"
185+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
186+ xml:space="preserve"><tspan
187+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
191+ sodipodi:role="line">Guess</tspan></text>
193+ inkscape:export-ydpi="61.120499"
194+ inkscape:export-xdpi="61.120499"
195+ sodipodi:linespacing="125%"
199+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
200+ xml:space="preserve"><tspan
201+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
205+ sodipodi:role="line">Goal</tspan></text>
207+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
213+ inkscape:export-xdpi="61.120499"
214+ inkscape:export-ydpi="61.120499" />
221+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
222+ inkscape:export-xdpi="61.120499"
223+ inkscape:export-ydpi="61.120499" />
225+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
231+ inkscape:export-xdpi="61.120499"
232+ inkscape:export-ydpi="61.120499" />
234+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
240+ inkscape:export-xdpi="61.120499"
241+ inkscape:export-ydpi="61.120499" />
248+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
249+ inkscape:export-xdpi="61.120499"
250+ inkscape:export-ydpi="61.120499" />
257+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
258+ inkscape:export-xdpi="61.120499"
259+ inkscape:export-ydpi="61.120499" />
261+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
262+ d="m 169,242.3622 -9,184"
264+ inkscape:connector-curvature="0"
265+ inkscape:export-xdpi="61.120499"
266+ inkscape:export-ydpi="61.120499"
267+ sodipodi:nodetypes="cc" />
269+ inkscape:connector-curvature="0"
271+ d="m 301,240.3622 -26,46"
272+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
273+ sodipodi:nodetypes="cc"
274+ inkscape:export-xdpi="61.120499"
275+ inkscape:export-ydpi="61.120499" />
277+ inkscape:export-ydpi="61.120499"
278+ inkscape:export-xdpi="61.120499"
279+ xml:space="preserve"
280+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
284+ sodipodi:linespacing="125%"><tspan
285+ sodipodi:role="line"
289+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">focus</tspan></text>
291+ inkscape:export-ydpi="61.120499"
292+ inkscape:export-xdpi="61.120499"
298+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
300+ inkscape:export-ydpi="61.120499"
301+ inkscape:export-xdpi="61.120499"
302+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
309+ inkscape:export-ydpi="61.120499"
310+ inkscape:export-xdpi="61.120499"
311+ xml:space="preserve"
312+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
316+ sodipodi:linespacing="125%"><tspan
318+ sodipodi:role="line"
321+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">List (TTName, Binder TT)</tspan><tspan
322+ sodipodi:role="line"
325+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
326+ id="tspan4182">Open unification constaints.</tspan></text>
328+ inkscape:export-ydpi="61.120499"
329+ inkscape:export-xdpi="61.120499"
330+ xml:space="preserve"
331+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
335+ sodipodi:linespacing="125%"><tspan
336+ sodipodi:role="line"
340+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">List TTName</tspan></text>
342+ sodipodi:linespacing="125%"
346+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
347+ xml:space="preserve"
348+ inkscape:export-xdpi="61.120499"
349+ inkscape:export-ydpi="61.120499"><tspan
350+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
354+ sodipodi:role="line">TT</tspan></text>
docs/image/elabProofStateEx1_1.pngnew file
Binary file not shown.
docs/image/elabProofStateEx1_1.svgnew file+312
@@ -0,0 +1,312 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="elabProofStateEx1_1.svg">
24+ bordercolor="#666666"
26+ inkscape:pageopacity="0.0"
27+ inkscape:pageshadow="2"
31+ inkscape:document-units="px"
32+ inkscape:current-layer="layer1"
34+ inkscape:window-width="1920"
35+ inkscape:window-height="1015"
36+ inkscape:window-x="0"
37+ inkscape:window-y="0"
38+ inkscape:window-maximized="1" />
44+ <dc:format>image/svg+xml</dc:format>
46+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
52+ inkscape:label="Layer 1"
53+ inkscape:groupmode="layer"
56+ sodipodi:linespacing="125%"
60+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
62+ inkscape:export-xdpi="61.120499"
63+ inkscape:export-ydpi="61.120499"><tspan
64+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
68+ id="tspan4144">hole_2</tspan></text>
70+ inkscape:export-ydpi="61.120499"
71+ inkscape:export-xdpi="61.120499"
72+ sodipodi:linespacing="125%"
76+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
77+ xml:space="preserve"><tspan
78+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
82+ sodipodi:role="line">Environment</tspan></text>
85+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
89+ sodipodi:linespacing="125%"
90+ inkscape:export-xdpi="61.120499"
91+ inkscape:export-ydpi="61.120499"><tspan
96+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1">Holes</tspan></text>
98+ inkscape:export-ydpi="61.120499"
99+ inkscape:export-xdpi="61.120499"
100+ sodipodi:linespacing="125%"
104+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
105+ xml:space="preserve"><tspan
106+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
110+ sodipodi:role="line">Guess</tspan></text>
112+ inkscape:export-ydpi="61.120499"
113+ inkscape:export-xdpi="61.120499"
114+ sodipodi:linespacing="125%"
118+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
119+ xml:space="preserve"><tspan
120+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
124+ sodipodi:role="line">Goal</tspan></text>
126+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
132+ inkscape:export-xdpi="61.120499"
133+ inkscape:export-ydpi="61.120499" />
140+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
141+ inkscape:export-xdpi="61.120499"
142+ inkscape:export-ydpi="61.120499" />
144+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
150+ inkscape:export-xdpi="61.120499"
151+ inkscape:export-ydpi="61.120499" />
153+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
159+ inkscape:export-xdpi="61.120499"
160+ inkscape:export-ydpi="61.120499" />
167+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
168+ inkscape:export-xdpi="61.120499"
169+ inkscape:export-ydpi="61.120499" />
176+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
177+ inkscape:export-xdpi="61.120499"
178+ inkscape:export-ydpi="61.120499" />
180+ inkscape:export-ydpi="61.120499"
181+ inkscape:export-xdpi="61.120499"
182+ xml:space="preserve"
183+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
187+ sodipodi:linespacing="125%"><tspan
189+ sodipodi:role="line"
192+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">hole_0</tspan></text>
194+ sodipodi:linespacing="125%"
198+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
199+ xml:space="preserve"
200+ inkscape:export-xdpi="61.120499"
201+ inkscape:export-ydpi="61.120499"><tspan
202+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
205+ sodipodi:role="line"
206+ id="tspan4161">[ ]</tspan></text>
208+ sodipodi:linespacing="125%"
212+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
213+ xml:space="preserve"
214+ inkscape:export-xdpi="61.120499"
215+ inkscape:export-ydpi="61.120499"><tspan
216+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
219+ sodipodi:role="line"
220+ id="tspan4165">starts off empty</tspan></text>
222+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
223+ d="m 154,237.3622 0,25"
225+ inkscape:connector-curvature="0"
226+ inkscape:export-xdpi="61.120499"
227+ inkscape:export-ydpi="61.120499"
228+ sodipodi:nodetypes="cc" />
230+ inkscape:export-ydpi="61.120499"
231+ inkscape:export-xdpi="61.120499"
232+ xml:space="preserve"
233+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
237+ sodipodi:linespacing="125%"><tspan
238+ sodipodi:role="line"
241+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
242+ id="tspan4790">(hole_2 , pi_arg : Nat->Nat)</tspan></text>
244+ inkscape:export-ydpi="61.120499"
245+ inkscape:export-xdpi="61.120499"
246+ xml:space="preserve"
247+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
251+ sodipodi:linespacing="125%"><tspan
253+ sodipodi:role="line"
256+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">this is the signature</tspan><tspan
257+ sodipodi:role="line"
260+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
261+ id="tspan4810">we are looking for</tspan></text>
263+ inkscape:connector-curvature="0"
265+ d="m 298,236.3622 -0.42683,58.52439"
266+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
267+ sodipodi:nodetypes="cc"
268+ inkscape:export-xdpi="61.120499"
269+ inkscape:export-ydpi="61.120499" />
271+ sodipodi:linespacing="125%"
275+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
276+ xml:space="preserve"
277+ inkscape:export-xdpi="61.120499"
278+ inkscape:export-ydpi="61.120499"><tspan
279+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
282+ sodipodi:role="line"
283+ id="tspan4802">machine chosen</tspan><tspan
284+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
287+ sodipodi:role="line"
288+ id="tspan4812">names for the holes</tspan></text>
290+ sodipodi:nodetypes="cc"
291+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
292+ d="m 432,265.3622 0.15244,56.82317"
294+ inkscape:connector-curvature="0"
295+ inkscape:export-xdpi="61.120499"
296+ inkscape:export-ydpi="61.120499" />
298+ inkscape:export-ydpi="61.120499"
299+ inkscape:export-xdpi="61.120499"
300+ xml:space="preserve"
301+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
305+ sodipodi:linespacing="125%"><tspan
307+ sodipodi:role="line"
310+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">no guess yet</tspan></text>
docs/image/elabProofStateEx1_2.pngnew file
Binary file not shown.
docs/image/elabProofStateEx1_2.svgnew file+281
@@ -0,0 +1,281 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="elabProofStateEx1_2.svg"
19+ inkscape:export-filename="/home/mjb/Idris-dev/docs/image/elabProofStateEx1_2.png"
20+ inkscape:export-xdpi="61.120499"
21+ inkscape:export-ydpi="61.120499">
25+ inkscape:stockid="Arrow1Mend"
30+ style="overflow:visible;"
31+ inkscape:isstock="true">
34+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
35+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
36+ transform="scale(0.4) rotate(180) translate(10,0)" />
42+ bordercolor="#666666"
44+ inkscape:pageopacity="0.0"
45+ inkscape:pageshadow="2"
47+ inkscape:cx="211.75967"
48+ inkscape:cy="688.76752"
49+ inkscape:document-units="px"
50+ inkscape:current-layer="layer1"
52+ inkscape:window-width="1920"
53+ inkscape:window-height="1015"
54+ inkscape:window-x="0"
55+ inkscape:window-y="0"
56+ inkscape:window-maximized="1" />
62+ <dc:format>image/svg+xml</dc:format>
64+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
70+ inkscape:label="Layer 1"
71+ inkscape:groupmode="layer"
74+ sodipodi:linespacing="125%"
78+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
80+ inkscape:export-xdpi="61.120499"
81+ inkscape:export-ydpi="61.120499"><tspan
82+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
86+ id="tspan4144">hole_2</tspan></text>
88+ inkscape:export-ydpi="61.120499"
89+ inkscape:export-xdpi="61.120499"
90+ sodipodi:linespacing="125%"
94+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
95+ xml:space="preserve"><tspan
96+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
100+ sodipodi:role="line">Environment</tspan></text>
102+ xml:space="preserve"
103+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
107+ sodipodi:linespacing="125%"
108+ inkscape:export-xdpi="61.120499"
109+ inkscape:export-ydpi="61.120499"><tspan
110+ sodipodi:role="line"
114+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1">Holes</tspan></text>
116+ inkscape:export-ydpi="61.120499"
117+ inkscape:export-xdpi="61.120499"
118+ sodipodi:linespacing="125%"
122+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
123+ xml:space="preserve"><tspan
124+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
128+ sodipodi:role="line">Guess</tspan></text>
130+ inkscape:export-ydpi="61.120499"
131+ inkscape:export-xdpi="61.120499"
132+ sodipodi:linespacing="125%"
136+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
137+ xml:space="preserve"><tspan
138+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
142+ sodipodi:role="line">Goal</tspan></text>
144+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
150+ inkscape:export-xdpi="61.120499"
151+ inkscape:export-ydpi="61.120499" />
158+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
159+ inkscape:export-xdpi="61.120499"
160+ inkscape:export-ydpi="61.120499" />
162+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
168+ inkscape:export-xdpi="61.120499"
169+ inkscape:export-ydpi="61.120499" />
171+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
177+ inkscape:export-xdpi="61.120499"
178+ inkscape:export-ydpi="61.120499" />
185+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
186+ inkscape:export-xdpi="61.120499"
187+ inkscape:export-ydpi="61.120499" />
194+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
195+ inkscape:export-xdpi="61.120499"
196+ inkscape:export-ydpi="61.120499" />
198+ inkscape:export-ydpi="61.120499"
199+ inkscape:export-xdpi="61.120499"
200+ xml:space="preserve"
201+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
205+ sodipodi:linespacing="125%"><tspan
207+ sodipodi:role="line"
210+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">hole_0</tspan></text>
212+ sodipodi:linespacing="125%"
216+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
217+ xml:space="preserve"
218+ inkscape:export-xdpi="61.120499"
219+ inkscape:export-ydpi="61.120499"><tspan
220+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
223+ sodipodi:role="line"
224+ id="tspan4161">(x, λ Nat)</tspan></text>
226+ inkscape:export-ydpi="61.120499"
227+ inkscape:export-xdpi="61.120499"
228+ xml:space="preserve"
229+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
233+ sodipodi:linespacing="125%"><tspan
234+ sodipodi:role="line"
237+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
238+ id="tspan4790">(hole_2 , Nat)</tspan></text>
240+ sodipodi:linespacing="125%"
244+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
245+ xml:space="preserve"
246+ inkscape:export-xdpi="61.120499"
247+ inkscape:export-ydpi="61.120499"><tspan
248+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
251+ sodipodi:role="line"
252+ id="tspan4812">replace the focussed hole</tspan><tspan
253+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
256+ sodipodi:role="line"
257+ id="tspan6225">with a lambda</tspan></text>
259+ sodipodi:nodetypes="cc"
260+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Mend)"
261+ d="m 307,242.3622 c -5.24693,34.96318 -108.05981,45.71777 -126,0"
263+ inkscape:connector-curvature="0"
264+ inkscape:export-xdpi="61.120499"
265+ inkscape:export-ydpi="61.120499" />
267+ inkscape:export-ydpi="61.120499"
268+ inkscape:export-xdpi="61.120499"
269+ xml:space="preserve"
270+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
274+ sodipodi:linespacing="125%"><tspan
276+ sodipodi:role="line"
279+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">x:Nat</tspan></text>
docs/image/elabProofStateEx1_3.pngnew file
Binary file not shown.
docs/image/elabProofStateEx1_3.svgnew file+244
@@ -0,0 +1,244 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="elabProofStateEx1_3.svg"
19+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"
20+ inkscape:export-xdpi="61.120499"
21+ inkscape:export-ydpi="61.120499">
27+ bordercolor="#666666"
29+ inkscape:pageopacity="0.0"
30+ inkscape:pageshadow="2"
32+ inkscape:cx="345.95856"
33+ inkscape:cy="688.76752"
34+ inkscape:document-units="px"
35+ inkscape:current-layer="layer1"
37+ inkscape:window-width="1920"
38+ inkscape:window-height="1015"
39+ inkscape:window-x="0"
40+ inkscape:window-y="0"
41+ inkscape:window-maximized="1" />
47+ <dc:format>image/svg+xml</dc:format>
49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
55+ inkscape:label="Layer 1"
56+ inkscape:groupmode="layer"
59+ sodipodi:linespacing="125%"
63+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
65+ inkscape:export-xdpi="61.120499"
66+ inkscape:export-ydpi="61.120499"
67+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan
68+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
72+ id="tspan4144">hole_2</tspan></text>
74+ inkscape:export-ydpi="61.120499"
75+ inkscape:export-xdpi="61.120499"
76+ sodipodi:linespacing="125%"
80+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
82+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan
83+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
87+ sodipodi:role="line">Environment</tspan></text>
90+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
94+ sodipodi:linespacing="125%"
95+ inkscape:export-xdpi="61.120499"
96+ inkscape:export-ydpi="61.120499"
97+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan
102+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1">Holes</tspan></text>
104+ inkscape:export-ydpi="61.120499"
105+ inkscape:export-xdpi="61.120499"
106+ sodipodi:linespacing="125%"
110+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
111+ xml:space="preserve"
112+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan
113+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
117+ sodipodi:role="line">Guess</tspan></text>
119+ inkscape:export-ydpi="61.120499"
120+ inkscape:export-xdpi="61.120499"
121+ sodipodi:linespacing="125%"
125+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
126+ xml:space="preserve"
127+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan
128+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;fill-opacity:1"
132+ sodipodi:role="line">Goal</tspan></text>
134+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
140+ inkscape:export-xdpi="61.120499"
141+ inkscape:export-ydpi="61.120499"
142+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png" />
149+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
150+ inkscape:export-xdpi="61.120499"
151+ inkscape:export-ydpi="61.120499"
152+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png" />
154+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
160+ inkscape:export-xdpi="61.120499"
161+ inkscape:export-ydpi="61.120499"
162+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png" />
164+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
170+ inkscape:export-xdpi="61.120499"
171+ inkscape:export-ydpi="61.120499"
172+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png" />
179+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
180+ inkscape:export-xdpi="61.120499"
181+ inkscape:export-ydpi="61.120499"
182+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png" />
184+ inkscape:export-ydpi="61.120499"
185+ inkscape:export-xdpi="61.120499"
186+ xml:space="preserve"
187+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
191+ sodipodi:linespacing="125%"
192+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan
194+ sodipodi:role="line"
197+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">hole_0</tspan></text>
199+ sodipodi:linespacing="125%"
203+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
204+ xml:space="preserve"
205+ inkscape:export-xdpi="61.120499"
206+ inkscape:export-ydpi="61.120499"
207+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan
208+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
211+ sodipodi:role="line"
212+ id="tspan4161">(x, λ Nat)</tspan></text>
214+ inkscape:export-ydpi="61.120499"
215+ inkscape:export-xdpi="61.120499"
216+ xml:space="preserve"
217+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
221+ sodipodi:linespacing="125%"
222+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan
223+ sodipodi:role="line"
226+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
227+ id="tspan4790">(hole_2 , Nat)</tspan></text>
229+ inkscape:export-ydpi="61.120499"
230+ inkscape:export-xdpi="61.120499"
231+ xml:space="preserve"
232+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
236+ sodipodi:linespacing="125%"
237+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan
239+ sodipodi:role="line"
242+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">x:Nat</tspan></text>
docs/image/fill.pngnew file
Binary file not shown.
docs/image/fill.svgnew file+163
@@ -0,0 +1,163 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 210 297"
17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"
18+ sodipodi:docname="fill.svg">
22+ inkscape:isstock="true"
23+ style="overflow:visible;"
28+ inkscape:stockid="Arrow1Mend">
30+ transform="scale(0.4) rotate(180) translate(10,0)"
31+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
32+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
36+ inkscape:stockid="Arrow1Mend"
41+ style="overflow:visible;"
42+ inkscape:isstock="true"
43+ inkscape:collect="always">
46+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
47+ style="fill-rule:evenodd;stroke:#ff0000;stroke-width:1pt;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
48+ transform="scale(0.4) rotate(180) translate(10,0)" />
54+ bordercolor="#666666"
56+ inkscape:pageopacity="0.0"
57+ inkscape:pageshadow="2"
61+ inkscape:document-units="mm"
62+ inkscape:current-layer="layer1"
64+ inkscape:window-width="1920"
65+ inkscape:window-height="1015"
66+ inkscape:window-x="0"
67+ inkscape:window-y="0"
68+ inkscape:window-maximized="1" />
74+ <dc:format>image/svg+xml</dc:format>
76+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
82+ inkscape:label="Layer 1"
83+ inkscape:groupmode="layer"
86+ style="fill:#ffff00;fill-opacity:1;stroke-width:0.26458332"
92+ inkscape:export-xdpi="61.120499"
93+ inkscape:export-ydpi="61.120499" />
96+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
100+ inkscape:export-xdpi="61.120499"
101+ inkscape:export-ydpi="61.120499"><tspan
102+ sodipodi:role="line"
106+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332">? {hole} . {hole}</tspan></text>
111+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
112+ xml:space="preserve"
113+ inkscape:export-xdpi="61.120499"
114+ inkscape:export-ydpi="61.120499"><tspan
115+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
119+ sodipodi:role="line">?{hole} ≈ Prelude.Nat.Z . {hole}</tspan></text>
124+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
125+ xml:space="preserve"
126+ inkscape:export-xdpi="61.120499"
127+ inkscape:export-ydpi="61.120499"><tspan
128+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332"
132+ sodipodi:role="line">fill `(Z)</tspan></text>
134+ style="fill:none;stroke:#ff0000;stroke-width:0.5291667;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Mend)"
135+ d="m 80.668481,106.30075 -0.0032,7.57492"
137+ inkscape:connector-curvature="0"
138+ sodipodi:nodetypes="cc"
139+ inkscape:export-xdpi="61.120499"
140+ inkscape:export-ydpi="61.120499" />
142+ inkscape:export-ydpi="61.120499"
143+ inkscape:export-xdpi="61.120499"
144+ xml:space="preserve"
145+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
149+ sodipodi:role="line"
153+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332">focus</tspan></text>
155+ inkscape:export-ydpi="61.120499"
156+ inkscape:export-xdpi="61.120499"
157+ sodipodi:nodetypes="cc"
158+ inkscape:connector-curvature="0"
160+ d="m 66.645564,94.659084 -0.0032,5.458256"
161+ style="fill:none;stroke:#0000ff;stroke-width:0.5291667;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker838)" />
docs/image/generateDatatype.pngnew file
Binary file not shown.
docs/image/generateDatatype.svgnew file+540
@@ -0,0 +1,540 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="generateDatatype.svg">
22+ inkscape:isstock="true"
23+ style="overflow:visible;"
28+ inkscape:stockid="Arrow2Mend">
30+ transform="scale(0.6) rotate(180) translate(0,0)"
31+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
32+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
36+ inkscape:stockid="Arrow2Mend"
41+ style="overflow:visible;"
42+ inkscape:isstock="true">
45+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
46+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
47+ transform="scale(0.6) rotate(180) translate(0,0)" />
50+ inkscape:isstock="true"
51+ style="overflow:visible;"
56+ inkscape:stockid="Arrow2Mend">
58+ transform="scale(0.6) rotate(180) translate(0,0)"
59+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
60+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
64+ inkscape:stockid="Arrow2Mend"
69+ style="overflow:visible;"
70+ inkscape:isstock="true">
73+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
74+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
75+ transform="scale(0.6) rotate(180) translate(0,0)" />
78+ inkscape:isstock="true"
79+ style="overflow:visible;"
84+ inkscape:stockid="Arrow2Mend"
85+ inkscape:collect="always">
87+ transform="scale(0.6) rotate(180) translate(0,0)"
88+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
89+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
93+ inkscape:stockid="Arrow2Mend"
98+ style="overflow:visible;"
99+ inkscape:isstock="true"
100+ inkscape:collect="always">
103+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
104+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
105+ transform="scale(0.6) rotate(180) translate(0,0)" />
111+ bordercolor="#666666"
113+ inkscape:pageopacity="0.0"
114+ inkscape:pageshadow="2"
116+ inkscape:cx="380.92935"
118+ inkscape:document-units="px"
119+ inkscape:current-layer="layer1"
121+ inkscape:window-width="1212"
122+ inkscape:window-height="1011"
123+ inkscape:window-x="-4"
124+ inkscape:window-y="0"
125+ inkscape:window-maximized="0" />
131+ <dc:format>image/svg+xml</dc:format>
133+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
134+ <dc:title></dc:title>
139+ inkscape:label="Layer 1"
140+ inkscape:groupmode="layer"
143+ style="opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
149+ inkscape:export-xdpi="61.120499"
150+ inkscape:export-ydpi="61.120499" />
157+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
158+ inkscape:export-xdpi="61.120499"
159+ inkscape:export-ydpi="61.120499" />
166+ style="opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
167+ inkscape:export-xdpi="61.120499"
168+ inkscape:export-ydpi="61.120499" />
170+ xml:space="preserve"
171+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
175+ sodipodi:linespacing="125%"
176+ inkscape:export-xdpi="61.120499"
177+ inkscape:export-ydpi="61.120499"><tspan
178+ sodipodi:role="line"
181+ y="227.3622">declareDatatype</tspan></text>
183+ sodipodi:linespacing="125%"
187+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
188+ xml:space="preserve"
189+ inkscape:export-xdpi="61.120499"
190+ inkscape:export-ydpi="61.120499"><tspan
194+ sodipodi:role="line">defineDatatype</tspan></text>
196+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker5133)"
197+ d="m 190,271.3622 0,48"
199+ inkscape:connector-curvature="0"
200+ inkscape:export-xdpi="61.120499"
201+ inkscape:export-ydpi="61.120499" />
203+ sodipodi:linespacing="125%"
207+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
208+ xml:space="preserve"
209+ inkscape:export-xdpi="61.120499"
210+ inkscape:export-ydpi="61.120499"><tspan
213+ sodipodi:role="line"
215+ style="font-size:15px;fill:#ff0000">Declare</tspan></text>
217+ xml:space="preserve"
218+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
222+ sodipodi:linespacing="125%"
223+ inkscape:export-xdpi="61.120499"
224+ inkscape:export-ydpi="61.120499"><tspan
225+ style="font-size:15px;fill:#0000ff"
226+ sodipodi:role="line"
229+ y="344.36218">name:TTName</tspan><tspan
230+ style="font-size:15px;fill:#0000ff"
232+ sodipodi:role="line"
234+ y="363.11218">arguments:List FunArg</tspan><tspan
235+ style="font-size:15px;fill:#0000ff"
237+ sodipodi:role="line"
239+ y="381.86218">returnType:Raw</tspan></text>
241+ xml:space="preserve"
242+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
246+ sodipodi:linespacing="125%"
247+ inkscape:export-xdpi="61.120499"
248+ inkscape:export-ydpi="61.120499"><tspan
249+ style="font-size:15px;fill:#0000ff;"
251+ sodipodi:role="line"
253+ y="313.36218">TyDecl</tspan></text>
255+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
261+ inkscape:export-xdpi="61.120499"
262+ inkscape:export-ydpi="61.120499" />
264+ inkscape:connector-curvature="0"
266+ d="m 247,364.3622 0,48"
267+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow2Mend)"
268+ inkscape:export-xdpi="61.120499"
269+ inkscape:export-ydpi="61.120499" />
271+ xml:space="preserve"
272+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
276+ sodipodi:linespacing="125%"
277+ inkscape:export-xdpi="61.120499"
278+ inkscape:export-ydpi="61.120499"><tspan
279+ style="font-size:15px;fill:#ff0000"
281+ sodipodi:role="line"
283+ y="408.36218">MkFunArg</tspan></text>
285+ sodipodi:linespacing="125%"
289+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
290+ xml:space="preserve"
291+ inkscape:export-xdpi="61.120499"
292+ inkscape:export-ydpi="61.120499"><tspan
296+ sodipodi:role="line"
297+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan
300+ sodipodi:role="line"
302+ style="font-size:15px;fill:#0000ff">type:Raw</tspan><tspan
305+ sodipodi:role="line"
306+ style="font-size:15px;fill:#0000ff"
307+ id="tspan5121">plicity:Plicity</tspan><tspan
310+ sodipodi:role="line"
311+ style="font-size:15px;fill:#0000ff"
312+ id="tspan5123">erasure:Erasure</tspan></text>
314+ sodipodi:linespacing="125%"
318+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
319+ xml:space="preserve"
320+ inkscape:export-xdpi="61.120499"
321+ inkscape:export-ydpi="61.120499"><tspan
324+ sodipodi:role="line"
326+ style="font-size:15px;fill:#0000ff">FunArg</tspan></text>
328+ sodipodi:linespacing="125%"
332+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
333+ xml:space="preserve"
334+ inkscape:export-xdpi="61.120499"
335+ inkscape:export-ydpi="61.120499"><tspan
338+ sodipodi:role="line"
340+ style="font-size:15px;fill:#ff0000">Explicit</tspan><tspan
343+ sodipodi:role="line"
344+ style="font-size:15px;fill:#ff0000"
345+ id="tspan5129">Implicit</tspan><tspan
348+ sodipodi:role="line"
349+ style="font-size:15px;fill:#ff0000"
350+ id="tspan5131">Constraint</tspan></text>
352+ inkscape:connector-curvature="0"
354+ d="m 169,473.3622 c -30.23945,2.9603 -39.98191,17.10078 -41,36"
355+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker5163)"
356+ sodipodi:nodetypes="cc"
357+ inkscape:export-xdpi="61.120499"
358+ inkscape:export-ydpi="61.120499" />
360+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker6325)"
361+ d="m 245,499.3622 0,28"
363+ inkscape:connector-curvature="0"
364+ sodipodi:nodetypes="cc"
365+ inkscape:export-xdpi="61.120499"
366+ inkscape:export-ydpi="61.120499" />
368+ sodipodi:linespacing="125%"
372+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
373+ xml:space="preserve"
374+ inkscape:export-xdpi="61.120499"
375+ inkscape:export-ydpi="61.120499"><tspan
378+ sodipodi:role="line"
380+ style="font-size:15px;fill:#ff0000">Erased</tspan><tspan
383+ sodipodi:role="line"
384+ style="font-size:15px;fill:#ff0000"
385+ id="tspan6773">NotErased</tspan></text>
387+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
393+ inkscape:export-xdpi="61.120499"
394+ inkscape:export-ydpi="61.120499" />
396+ inkscape:connector-curvature="0"
398+ d="m 458,271.3622 0,48"
399+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker5133)"
400+ inkscape:export-xdpi="61.120499"
401+ inkscape:export-ydpi="61.120499" />
403+ xml:space="preserve"
404+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
408+ sodipodi:linespacing="125%"
409+ inkscape:export-xdpi="61.120499"
410+ inkscape:export-ydpi="61.120499"><tspan
411+ style="font-size:15px;fill:#ff0000"
413+ sodipodi:role="line"
415+ y="295.36218">DefineDatatype</tspan></text>
417+ sodipodi:linespacing="125%"
421+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
422+ xml:space="preserve"
423+ inkscape:export-xdpi="61.120499"
424+ inkscape:export-ydpi="61.120499"><tspan
427+ sodipodi:role="line"
429+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan
432+ sodipodi:role="line"
433+ style="font-size:15px;fill:#0000ff"
434+ id="tspan7130">constructors : List ConstructorDefn</tspan></text>
436+ sodipodi:linespacing="125%"
440+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
441+ xml:space="preserve"
442+ inkscape:export-xdpi="61.120499"
443+ inkscape:export-ydpi="61.120499"><tspan
446+ sodipodi:role="line"
448+ style="font-size:15px;fill:#0000ff">DataDefn</tspan></text>
450+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
456+ inkscape:export-xdpi="61.120499"
457+ inkscape:export-ydpi="61.120499" />
459+ inkscape:connector-curvature="0"
461+ d="m 539,367.3622 0,48"
462+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker6819)"
463+ inkscape:export-xdpi="61.120499"
464+ inkscape:export-ydpi="61.120499" />
466+ xml:space="preserve"
467+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
471+ sodipodi:linespacing="125%"
472+ inkscape:export-xdpi="61.120499"
473+ inkscape:export-ydpi="61.120499"><tspan
474+ style="font-size:15px;fill:#ff0000"
476+ sodipodi:role="line"
478+ y="386.36218">Constructor</tspan></text>
480+ sodipodi:linespacing="125%"
484+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
485+ xml:space="preserve"
486+ inkscape:export-xdpi="61.120499"
487+ inkscape:export-ydpi="61.120499"><tspan
491+ sodipodi:role="line"
492+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan
495+ sodipodi:role="line"
497+ style="font-size:15px;fill:#0000ff">arguments:List FunArg</tspan><tspan
500+ sodipodi:role="line"
502+ style="font-size:15px;fill:#0000ff">returnType:Raw</tspan></text>
504+ sodipodi:linespacing="125%"
508+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
509+ xml:space="preserve"
510+ inkscape:export-xdpi="61.120499"
511+ inkscape:export-ydpi="61.120499"><tspan
514+ sodipodi:role="line"
516+ style="font-size:15px;fill:#0000ff">ConstructorDefn</tspan></text>
518+ inkscape:export-ydpi="61.120499"
519+ inkscape:export-xdpi="61.120499"
520+ sodipodi:linespacing="125%"
524+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
525+ xml:space="preserve"><tspan
528+ sodipodi:role="line"
530+ style="font-size:15px;fill:#ff0000">MkFunArg</tspan></text>
532+ inkscape:export-ydpi="61.120499"
533+ inkscape:export-xdpi="61.120499"
534+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker7147)"
535+ d="m 379,458.3622 -80,-35"
537+ inkscape:connector-curvature="0"
538+ sodipodi:nodetypes="cc" />
docs/image/generateFunction.pngnew file
Binary file not shown.
docs/image/generateFunction.svgnew file+588
@@ -0,0 +1,588 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="generateFunction.svg">
22+ inkscape:isstock="true"
23+ style="overflow:visible;"
28+ inkscape:stockid="Arrow2Mend">
30+ transform="scale(0.6) rotate(180) translate(0,0)"
31+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
32+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
36+ inkscape:isstock="true"
37+ style="overflow:visible;"
42+ inkscape:stockid="Arrow2Mend">
44+ transform="scale(0.6) rotate(180) translate(0,0)"
45+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
46+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
50+ inkscape:stockid="Arrow2Mend"
55+ style="overflow:visible;"
56+ inkscape:isstock="true"
57+ inkscape:collect="always">
60+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
61+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
62+ transform="scale(0.6) rotate(180) translate(0,0)" />
65+ inkscape:isstock="true"
66+ style="overflow:visible;"
71+ inkscape:stockid="Arrow2Mend">
73+ transform="scale(0.6) rotate(180) translate(0,0)"
74+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
75+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
79+ inkscape:stockid="Arrow2Mend"
84+ style="overflow:visible;"
85+ inkscape:isstock="true">
88+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
89+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
90+ transform="scale(0.6) rotate(180) translate(0,0)" />
93+ inkscape:isstock="true"
94+ style="overflow:visible;"
99+ inkscape:stockid="Arrow2Mend"
100+ inkscape:collect="always">
102+ transform="scale(0.6) rotate(180) translate(0,0)"
103+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
104+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
108+ inkscape:stockid="Arrow2Mend"
113+ style="overflow:visible;"
114+ inkscape:isstock="true"
115+ inkscape:collect="always">
118+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
119+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
120+ transform="scale(0.6) rotate(180) translate(0,0)" />
126+ bordercolor="#666666"
128+ inkscape:pageopacity="0.0"
129+ inkscape:pageshadow="2"
131+ inkscape:cx="380.92935"
133+ inkscape:document-units="px"
134+ inkscape:current-layer="layer1"
136+ inkscape:window-width="1212"
137+ inkscape:window-height="1011"
138+ inkscape:window-x="0"
139+ inkscape:window-y="0"
140+ inkscape:window-maximized="0" />
146+ <dc:format>image/svg+xml</dc:format>
148+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
154+ inkscape:label="Layer 1"
155+ inkscape:groupmode="layer"
158+ style="opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
164+ inkscape:export-xdpi="61.120499"
165+ inkscape:export-ydpi="61.120499" />
172+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
173+ inkscape:export-xdpi="61.120499"
174+ inkscape:export-ydpi="61.120499" />
181+ style="opacity:1;fill:none;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
182+ inkscape:export-xdpi="61.120499"
183+ inkscape:export-ydpi="61.120499" />
185+ xml:space="preserve"
186+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
190+ sodipodi:linespacing="125%"
191+ inkscape:export-xdpi="61.120499"
192+ inkscape:export-ydpi="61.120499"><tspan
193+ sodipodi:role="line"
196+ y="227.3622">declareType</tspan></text>
198+ sodipodi:linespacing="125%"
202+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
203+ xml:space="preserve"
204+ inkscape:export-xdpi="61.120499"
205+ inkscape:export-ydpi="61.120499"><tspan
209+ sodipodi:role="line">defineFunction</tspan></text>
211+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker5133)"
212+ d="m 190,271.3622 0,48"
214+ inkscape:connector-curvature="0"
215+ inkscape:export-xdpi="61.120499"
216+ inkscape:export-ydpi="61.120499" />
218+ sodipodi:linespacing="125%"
222+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
223+ xml:space="preserve"
224+ inkscape:export-xdpi="61.120499"
225+ inkscape:export-ydpi="61.120499"><tspan
228+ sodipodi:role="line"
230+ style="font-size:15px;fill:#ff0000">Declare</tspan></text>
232+ xml:space="preserve"
233+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
237+ sodipodi:linespacing="125%"
238+ inkscape:export-xdpi="61.120499"
239+ inkscape:export-ydpi="61.120499"><tspan
240+ style="font-size:15px;fill:#0000ff"
241+ sodipodi:role="line"
244+ y="344.36218">name:TTName</tspan><tspan
245+ style="font-size:15px;fill:#0000ff"
247+ sodipodi:role="line"
249+ y="363.11218">arguments:List FunArg</tspan><tspan
250+ style="font-size:15px;fill:#0000ff"
252+ sodipodi:role="line"
254+ y="381.86218">returnType:Raw</tspan></text>
256+ xml:space="preserve"
257+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
261+ sodipodi:linespacing="125%"
262+ inkscape:export-xdpi="61.120499"
263+ inkscape:export-ydpi="61.120499"><tspan
264+ style="font-size:15px;fill:#0000ff;"
266+ sodipodi:role="line"
268+ y="313.36218">TyDecl</tspan></text>
270+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
276+ inkscape:export-xdpi="61.120499"
277+ inkscape:export-ydpi="61.120499" />
279+ inkscape:connector-curvature="0"
281+ d="m 247,364.3622 0,48"
282+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow2Mend)"
283+ inkscape:export-xdpi="61.120499"
284+ inkscape:export-ydpi="61.120499" />
286+ xml:space="preserve"
287+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
291+ sodipodi:linespacing="125%"
292+ inkscape:export-xdpi="61.120499"
293+ inkscape:export-ydpi="61.120499"><tspan
294+ style="font-size:15px;fill:#ff0000"
296+ sodipodi:role="line"
298+ y="408.36218">MkFunArg</tspan></text>
300+ sodipodi:linespacing="125%"
304+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
305+ xml:space="preserve"
306+ inkscape:export-xdpi="61.120499"
307+ inkscape:export-ydpi="61.120499"><tspan
311+ sodipodi:role="line"
312+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan
315+ sodipodi:role="line"
317+ style="font-size:15px;fill:#0000ff">type:Raw</tspan><tspan
320+ sodipodi:role="line"
321+ style="font-size:15px;fill:#0000ff"
322+ id="tspan5121">plicity:Plicity</tspan><tspan
325+ sodipodi:role="line"
326+ style="font-size:15px;fill:#0000ff"
327+ id="tspan5123">erasure:Erasure</tspan></text>
329+ sodipodi:linespacing="125%"
333+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
334+ xml:space="preserve"
335+ inkscape:export-xdpi="61.120499"
336+ inkscape:export-ydpi="61.120499"><tspan
339+ sodipodi:role="line"
341+ style="font-size:15px;fill:#0000ff">FunArg</tspan></text>
343+ sodipodi:linespacing="125%"
347+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
348+ xml:space="preserve"
349+ inkscape:export-xdpi="61.120499"
350+ inkscape:export-ydpi="61.120499"><tspan
353+ sodipodi:role="line"
355+ style="font-size:15px;fill:#ff0000">Explicit</tspan><tspan
358+ sodipodi:role="line"
359+ style="font-size:15px;fill:#ff0000"
360+ id="tspan5129">Implicit</tspan><tspan
363+ sodipodi:role="line"
364+ style="font-size:15px;fill:#ff0000"
365+ id="tspan5131">Constraint</tspan></text>
367+ inkscape:connector-curvature="0"
369+ d="m 169,473.3622 c -30.23945,2.9603 -39.98191,17.10078 -41,36"
370+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker5163)"
371+ sodipodi:nodetypes="cc"
372+ inkscape:export-xdpi="61.120499"
373+ inkscape:export-ydpi="61.120499" />
375+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker6325)"
376+ d="m 245,499.3622 0,28"
378+ inkscape:connector-curvature="0"
379+ sodipodi:nodetypes="cc"
380+ inkscape:export-xdpi="61.120499"
381+ inkscape:export-ydpi="61.120499" />
383+ sodipodi:linespacing="125%"
387+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
388+ xml:space="preserve"
389+ inkscape:export-xdpi="61.120499"
390+ inkscape:export-ydpi="61.120499"><tspan
393+ sodipodi:role="line"
395+ style="font-size:15px;fill:#ff0000">Erased</tspan><tspan
398+ sodipodi:role="line"
399+ style="font-size:15px;fill:#ff0000"
400+ id="tspan6773">NotErased</tspan></text>
402+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
408+ inkscape:export-xdpi="61.120499"
409+ inkscape:export-ydpi="61.120499" />
411+ inkscape:connector-curvature="0"
413+ d="m 458,271.3622 0,48"
414+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker5133)"
415+ inkscape:export-xdpi="61.120499"
416+ inkscape:export-ydpi="61.120499" />
418+ xml:space="preserve"
419+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
423+ sodipodi:linespacing="125%"
424+ inkscape:export-xdpi="61.120499"
425+ inkscape:export-ydpi="61.120499"><tspan
426+ style="font-size:15px;fill:#ff0000"
428+ sodipodi:role="line"
430+ y="295.36218">DefineFun</tspan></text>
432+ sodipodi:linespacing="125%"
436+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
437+ xml:space="preserve"
438+ inkscape:export-xdpi="61.120499"
439+ inkscape:export-ydpi="61.120499"><tspan
442+ sodipodi:role="line"
444+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan
447+ sodipodi:role="line"
448+ style="font-size:15px;fill:#0000ff"
449+ id="tspan7130">clauses : List (FunClause a)</tspan></text>
451+ sodipodi:linespacing="125%"
455+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
456+ xml:space="preserve"
457+ inkscape:export-xdpi="61.120499"
458+ inkscape:export-ydpi="61.120499"><tspan
461+ sodipodi:role="line"
463+ style="font-size:15px;fill:#0000ff">FunDefn</tspan></text>
465+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
471+ inkscape:export-xdpi="61.120499"
472+ inkscape:export-ydpi="61.120499" />
474+ inkscape:connector-curvature="0"
476+ d="m 552,370.3622 0,86"
477+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker6819)"
478+ inkscape:export-xdpi="61.120499"
479+ inkscape:export-ydpi="61.120499"
480+ sodipodi:nodetypes="cc" />
482+ xml:space="preserve"
483+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
487+ sodipodi:linespacing="125%"
488+ inkscape:export-xdpi="61.120499"
489+ inkscape:export-ydpi="61.120499"><tspan
490+ style="font-size:15px;fill:#ff0000"
492+ sodipodi:role="line"
494+ y="418.36218">MkFunClause</tspan></text>
496+ sodipodi:linespacing="125%"
500+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
501+ xml:space="preserve"
502+ inkscape:export-xdpi="61.120499"
503+ inkscape:export-ydpi="61.120499"><tspan
506+ sodipodi:role="line"
508+ style="font-size:15px;fill:#0000ff">lhs:a</tspan><tspan
511+ sodipodi:role="line"
512+ style="font-size:15px;fill:#0000ff"
513+ id="tspan4330">rhs:a</tspan></text>
515+ sodipodi:linespacing="125%"
519+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
520+ xml:space="preserve"
521+ inkscape:export-xdpi="61.120499"
522+ inkscape:export-ydpi="61.120499"><tspan
525+ sodipodi:role="line"
527+ style="font-size:15px;fill:#0000ff">FunClause</tspan></text>
529+ inkscape:export-ydpi="61.120499"
530+ inkscape:export-xdpi="61.120499"
531+ sodipodi:linespacing="125%"
535+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
536+ xml:space="preserve"><tspan
539+ sodipodi:role="line"
541+ style="font-size:15px;fill:#ff0000">MkImpossibleClause</tspan></text>
543+ inkscape:export-ydpi="61.120499"
544+ inkscape:export-xdpi="61.120499"
550+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
552+ inkscape:export-ydpi="61.120499"
553+ inkscape:export-xdpi="61.120499"
554+ xml:space="preserve"
555+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
559+ sodipodi:linespacing="125%"><tspan
561+ style="font-size:15px;fill:#0000ff"
562+ sodipodi:role="line"
564+ y="483.36218">lhs:a</tspan></text>
566+ inkscape:export-ydpi="61.120499"
567+ inkscape:export-xdpi="61.120499"
568+ xml:space="preserve"
569+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
573+ sodipodi:linespacing="125%"><tspan
574+ style="font-size:15px;fill:#0000ff"
576+ sodipodi:role="line"
578+ y="452.36218">FunClause</tspan></text>
580+ inkscape:export-ydpi="61.120499"
581+ inkscape:export-xdpi="61.120499"
582+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4348)"
583+ d="m 450,371.3622 0,84"
585+ inkscape:connector-curvature="0"
586+ sodipodi:nodetypes="cc" />
docs/image/generateFunction2.pngnew file
Binary file not shown.
docs/image/generateFunction2.svgnew file+430
@@ -0,0 +1,430 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="generateFunction2.svg">
22+ inkscape:isstock="true"
23+ style="overflow:visible;"
28+ inkscape:stockid="Arrow2Mend">
30+ transform="scale(0.6) rotate(180) translate(0,0)"
31+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
32+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
36+ inkscape:stockid="Arrow2Mend"
41+ style="overflow:visible;"
42+ inkscape:isstock="true">
45+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
46+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
47+ transform="scale(0.6) rotate(180) translate(0,0)" />
50+ inkscape:isstock="true"
51+ style="overflow:visible;"
56+ inkscape:stockid="Arrow2Mend"
57+ inkscape:collect="always">
59+ transform="scale(0.6) rotate(180) translate(0,0)"
60+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
61+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
65+ inkscape:isstock="true"
66+ style="overflow:visible;"
71+ inkscape:stockid="Arrow2Mend">
73+ transform="scale(0.6) rotate(180) translate(0,0)"
74+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
75+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
79+ inkscape:stockid="Arrow2Mend"
84+ style="overflow:visible;"
85+ inkscape:isstock="true">
88+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
89+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
90+ transform="scale(0.6) rotate(180) translate(0,0)" />
93+ inkscape:stockid="Arrow2Mend"
98+ style="overflow:visible;"
99+ inkscape:isstock="true">
102+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
103+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
104+ transform="scale(0.6) rotate(180) translate(0,0)" />
107+ inkscape:isstock="true"
108+ style="overflow:visible;"
113+ inkscape:stockid="Arrow2Mend"
114+ inkscape:collect="always">
116+ transform="scale(0.6) rotate(180) translate(0,0)"
117+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
118+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
122+ inkscape:stockid="Arrow2Mend"
127+ style="overflow:visible;"
128+ inkscape:isstock="true"
129+ inkscape:collect="always">
132+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
133+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
134+ transform="scale(0.6) rotate(180) translate(0,0)" />
137+ inkscape:isstock="true"
138+ style="overflow:visible;"
143+ inkscape:stockid="Arrow2Mend">
145+ transform="scale(0.6) rotate(180) translate(0,0)"
146+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
147+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
151+ inkscape:isstock="true"
152+ style="overflow:visible;"
157+ inkscape:stockid="Arrow2Mend">
159+ transform="scale(0.6) rotate(180) translate(0,0)"
160+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
161+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
165+ inkscape:stockid="Arrow2Mend"
170+ style="overflow:visible;"
171+ inkscape:isstock="true">
174+ style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#ff0000;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
175+ d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
176+ transform="scale(0.6) rotate(180) translate(0,0)" />
182+ bordercolor="#666666"
184+ inkscape:pageopacity="0.0"
185+ inkscape:pageshadow="2"
187+ inkscape:cx="380.92935"
188+ inkscape:cy="592.42473"
189+ inkscape:document-units="px"
190+ inkscape:current-layer="layer1"
192+ inkscape:window-width="1067"
193+ inkscape:window-height="1011"
194+ inkscape:window-x="0"
195+ inkscape:window-y="0"
196+ inkscape:window-maximized="0" />
202+ <dc:format>image/svg+xml</dc:format>
204+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
210+ inkscape:label="Layer 1"
211+ inkscape:groupmode="layer"
214+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
220+ inkscape:export-xdpi="61.120499"
221+ inkscape:export-ydpi="61.120499" />
223+ xml:space="preserve"
224+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
228+ sodipodi:linespacing="125%"
229+ inkscape:export-xdpi="61.120499"
230+ inkscape:export-ydpi="61.120499"><tspan
231+ style="font-size:15px;fill:#ff0000"
233+ sodipodi:role="line"
235+ y="211.36218">RBind <tspan
236+ style="fill:#0000ff"
237+ id="tspan4367">TTName</tspan> (<tspan
238+ style="fill:#0000ff"
239+ id="tspan4363">Binder TT</tspan>) <tspan
240+ style="fill:#0000ff"
241+ id="tspan4365"> TT</tspan></tspan></text>
243+ sodipodi:linespacing="125%"
247+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
248+ xml:space="preserve"
249+ inkscape:export-xdpi="61.120499"
250+ inkscape:export-ydpi="61.120499"><tspan
253+ sodipodi:role="line"
255+ style="font-size:15px;fill:#0000ff">lhs:a</tspan><tspan
258+ sodipodi:role="line"
259+ style="font-size:15px;fill:#0000ff"
260+ id="tspan4330">rhs:a</tspan></text>
262+ sodipodi:linespacing="125%"
266+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
267+ xml:space="preserve"
268+ inkscape:export-xdpi="61.120499"
269+ inkscape:export-ydpi="61.120499"><tspan
272+ sodipodi:role="line"
274+ style="font-size:15px;fill:#0000ff">FunClause</tspan></text>
276+ inkscape:export-ydpi="61.120499"
277+ inkscape:export-xdpi="61.120499"
283+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
285+ inkscape:export-ydpi="61.120499"
286+ inkscape:export-xdpi="61.120499"
287+ xml:space="preserve"
288+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
292+ sodipodi:linespacing="125%"><tspan
293+ style="font-size:15px;fill:#0000ff"
295+ sodipodi:role="line"
297+ y="168.36218">Raw</tspan></text>
299+ inkscape:export-ydpi="61.120499"
300+ inkscape:export-xdpi="61.120499"
301+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4349)"
302+ d="m 247,145.3622 c 28.96221,0.27049 22.31485,19.06346 -7,48"
304+ inkscape:connector-curvature="0"
305+ sodipodi:nodetypes="cc" />
307+ inkscape:export-ydpi="61.120499"
308+ inkscape:export-xdpi="61.120499"
309+ sodipodi:linespacing="125%"
313+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
314+ xml:space="preserve"><tspan
317+ sodipodi:role="line"
319+ style="font-size:15px;fill:#ff0000">PVar <tspan
320+ style="fill:#0000ff"
321+ id="tspan4415">a</tspan> (<tspan
322+ style="fill:#0000ff"
323+ id="tspan4369">Binder a</tspan>)</tspan></text>
325+ sodipodi:nodetypes="cc"
326+ inkscape:connector-curvature="0"
328+ d="m 336,214.3622 0,158"
329+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4407)"
330+ inkscape:export-xdpi="61.120499"
331+ inkscape:export-ydpi="61.120499" />
333+ xml:space="preserve"
334+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
338+ sodipodi:linespacing="125%"
339+ inkscape:export-xdpi="61.120499"
340+ inkscape:export-ydpi="61.120499"><tspan
341+ style="font-size:15px;fill:#ff0000"
343+ sodipodi:role="line"
345+ y="196.36218">RApp Raw Raw</tspan></text>
347+ inkscape:export-ydpi="61.120499"
348+ inkscape:export-xdpi="61.120499"
349+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4359)"
350+ d="m 396,216.3622 c 22.67213,51.77028 75.6614,-87.82153 4,-37"
352+ inkscape:connector-curvature="0"
353+ sodipodi:nodetypes="cc" />
355+ style="opacity:1;fill:none;fill-opacity:1;stroke:#0000ff;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
361+ inkscape:export-xdpi="61.120499"
362+ inkscape:export-ydpi="61.120499" />
364+ sodipodi:linespacing="125%"
368+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
369+ xml:space="preserve"
370+ inkscape:export-xdpi="61.120499"
371+ inkscape:export-ydpi="61.120499"><tspan
374+ sodipodi:role="line"
376+ style="font-size:15px;fill:#0000ff">Binder a</tspan></text>
378+ xml:space="preserve"
379+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
383+ sodipodi:linespacing="125%"
384+ inkscape:export-xdpi="61.120499"
385+ inkscape:export-ydpi="61.120499"><tspan
386+ style="font-size:15px;fill:#ff0000"
388+ sodipodi:role="line"
390+ y="254.36218">`{{code}}</tspan></text>
392+ inkscape:export-ydpi="61.120499"
393+ inkscape:export-xdpi="61.120499"
394+ sodipodi:linespacing="125%"
398+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
399+ xml:space="preserve"><tspan
402+ sodipodi:role="line"
404+ style="font-size:15px;fill:#ff0000">`{{body}}</tspan></text>
406+ inkscape:export-ydpi="61.120499"
407+ inkscape:export-xdpi="61.120499"
408+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4427)"
409+ d="m 266,218.3622 -26,17"
411+ inkscape:connector-curvature="0"
412+ sodipodi:nodetypes="cc" />
414+ sodipodi:nodetypes="cc"
415+ inkscape:connector-curvature="0"
417+ d="m 272,217.3622 9,42"
418+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4433)"
419+ inkscape:export-xdpi="61.120499"
420+ inkscape:export-ydpi="61.120499" />
422+ sodipodi:nodetypes="cc"
423+ inkscape:connector-curvature="0"
425+ d="m 248,124.3622 c 30.28183,6.20207 31.24081,36.56361 -10,70"
426+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4439)"
427+ inkscape:export-xdpi="61.120499"
428+ inkscape:export-ydpi="61.120499" />
docs/image/idrisTopLevel.pngnew file
Binary file not shown.
docs/image/idrisTopLevel.svgnew file+524
@@ -0,0 +1,524 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 744.09448819 1052.3622047"
17+ inkscape:version="0.91 r13725"
18+ sodipodi:docname="idrisTopLevel.svg">
22+ inkscape:stockid="Arrow1Mend"
27+ style="overflow:visible;"
28+ inkscape:isstock="true">
31+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
32+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
33+ transform="scale(0.4) rotate(180) translate(10,0)" />
36+ inkscape:isstock="true"
37+ style="overflow:visible;"
42+ inkscape:stockid="Arrow1Mend"
43+ inkscape:collect="always">
45+ transform="scale(0.4) rotate(180) translate(10,0)"
46+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
47+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
51+ inkscape:stockid="Arrow1Mend"
56+ style="overflow:visible;"
57+ inkscape:isstock="true"
58+ inkscape:collect="always">
61+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
62+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
63+ transform="scale(0.4) rotate(180) translate(10,0)" />
66+ inkscape:stockid="Arrow1Mend"
71+ style="overflow:visible;"
72+ inkscape:isstock="true">
75+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
76+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
77+ transform="scale(0.4) rotate(180) translate(10,0)" />
80+ inkscape:isstock="true"
81+ style="overflow:visible;"
86+ inkscape:stockid="Arrow1Mend"
87+ inkscape:collect="always">
89+ transform="scale(0.4) rotate(180) translate(10,0)"
90+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
91+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
95+ inkscape:stockid="Arrow1Mend"
100+ style="overflow:visible;"
101+ inkscape:isstock="true"
102+ inkscape:collect="always">
105+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
106+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
107+ transform="scale(0.4) rotate(180) translate(10,0)" />
110+ inkscape:stockid="Arrow1Mend"
115+ style="overflow:visible;"
116+ inkscape:isstock="true"
117+ inkscape:collect="always">
120+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
121+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
122+ transform="scale(0.4) rotate(180) translate(10,0)" />
128+ bordercolor="#666666"
130+ inkscape:pageopacity="0.0"
131+ inkscape:pageshadow="2"
135+ inkscape:document-units="px"
136+ inkscape:current-layer="layer1"
138+ inkscape:window-width="1744"
139+ inkscape:window-height="1011"
140+ inkscape:window-x="-4"
141+ inkscape:window-y="0"
142+ inkscape:window-maximized="0" />
148+ <dc:format>image/svg+xml</dc:format>
150+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
156+ inkscape:label="Layer 1"
157+ inkscape:groupmode="layer"
160+ xml:space="preserve"
161+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
165+ sodipodi:linespacing="125%"
166+ inkscape:export-xdpi="61.120499"
167+ inkscape:export-ydpi="61.120499"><tspan
168+ sodipodi:role="line"
172+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:25px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000">Idris</tspan></text>
174+ sodipodi:linespacing="125%"
178+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
179+ xml:space="preserve"
180+ inkscape:export-xdpi="61.120499"
181+ inkscape:export-ydpi="61.120499"><tspan
182+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:25px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
186+ sodipodi:role="line">Idris</tspan></text>
188+ xml:space="preserve"
189+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;"
193+ sodipodi:linespacing="125%"
194+ inkscape:export-xdpi="61.120499"
195+ inkscape:export-ydpi="61.120499"><tspan
196+ sodipodi:role="line"
200+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:25px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;">~</tspan></text>
202+ sodipodi:linespacing="125%"
206+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
207+ xml:space="preserve"
208+ inkscape:export-xdpi="61.120499"
209+ inkscape:export-ydpi="61.120499"><tspan
210+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:25px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
214+ sodipodi:role="line">TT</tspan></text>
216+ xml:space="preserve"
217+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
221+ sodipodi:linespacing="125%"
222+ inkscape:export-xdpi="61.120499"
223+ inkscape:export-ydpi="61.120499"><tspan
224+ sodipodi:role="line"
228+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:25px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000">Executable</tspan></text>
230+ sodipodi:linespacing="125%"
234+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
235+ xml:space="preserve"
236+ inkscape:export-xdpi="61.120499"
237+ inkscape:export-ydpi="61.120499"><tspan
238+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
242+ sodipodi:role="line">desugaring</tspan></text>
244+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Mend)"
245+ d="M 81.977612,407.11261 188,407.3622"
247+ inkscape:connector-curvature="0"
248+ inkscape:export-xdpi="61.120499"
249+ inkscape:export-ydpi="61.120499"
250+ sodipodi:nodetypes="cc" />
252+ xml:space="preserve"
253+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
257+ sodipodi:linespacing="125%"
258+ inkscape:export-xdpi="61.120499"
259+ inkscape:export-ydpi="61.120499"><tspan
260+ sodipodi:role="line"
264+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'">elaboration</tspan></text>
266+ sodipodi:linespacing="125%"
270+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
271+ xml:space="preserve"
272+ inkscape:export-xdpi="61.120499"
273+ inkscape:export-ydpi="61.120499"><tspan
274+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:20px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
278+ sodipodi:role="line">compilation</tspan></text>
280+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4830)"
281+ d="m 495,405.33981 105,0.0224"
283+ inkscape:connector-curvature="0"
284+ inkscape:export-xdpi="61.120499"
285+ inkscape:export-ydpi="61.120499"
286+ sodipodi:nodetypes="cc" />
288+ inkscape:export-ydpi="61.120499"
289+ inkscape:export-xdpi="61.120499"
290+ sodipodi:linespacing="125%"
294+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
295+ xml:space="preserve"><tspan
296+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:25px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
300+ sodipodi:role="line">C</tspan></text>
302+ xml:space="preserve"
303+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
307+ sodipodi:linespacing="125%"
308+ inkscape:export-xdpi="61.120499"
309+ inkscape:export-ydpi="61.120499"><tspan
310+ sodipodi:role="line"
314+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:25px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000">JS</tspan></text>
316+ inkscape:export-ydpi="61.120499"
317+ inkscape:export-xdpi="61.120499"
318+ inkscape:connector-curvature="0"
320+ d="m 495,406.3622 104,26"
321+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:8, 2;stroke-dashoffset:0;stroke-opacity:1;marker-end:url(#marker4176)"
322+ sodipodi:nodetypes="cc" />
324+ sodipodi:nodetypes="cc"
325+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:12, 2;stroke-dashoffset:0;stroke-opacity:1;marker-end:url(#marker4182)"
326+ d="M 495,405.90781 599,467.3622"
328+ inkscape:connector-curvature="0"
329+ inkscape:export-xdpi="61.120499"
330+ inkscape:export-ydpi="61.120499" />
332+ inkscape:export-ydpi="61.120499"
333+ inkscape:export-xdpi="61.120499"
334+ xml:space="preserve"
335+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
339+ sodipodi:linespacing="125%"><tspan
340+ sodipodi:role="line"
343+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
344+ id="tspan4190">Add implicitly quantified variables.</tspan><tspan
345+ sodipodi:role="line"
348+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
349+ id="tspan4191">Conditional expressions replaced by function calls.</tspan></text>
351+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
352+ d="m 120.29902,440.01416 0.098,70.81863"
354+ inkscape:connector-curvature="0"
355+ inkscape:export-xdpi="61.120499"
356+ inkscape:export-ydpi="61.120499"
357+ sodipodi:nodetypes="cc" />
359+ sodipodi:linespacing="125%"
363+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
364+ xml:space="preserve"
365+ inkscape:export-xdpi="61.120499"
366+ inkscape:export-ydpi="61.120499"><tspan
368+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
371+ sodipodi:role="line">proof tactics</tspan></text>
373+ inkscape:connector-curvature="0"
375+ d="m 382.73881,368.53384 0.16418,32.3209"
376+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
377+ sodipodi:nodetypes="cc"
378+ inkscape:export-xdpi="61.120499"
379+ inkscape:export-ydpi="61.120499" />
381+ inkscape:export-ydpi="61.120499"
382+ inkscape:export-xdpi="61.120499"
383+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4197)"
384+ d="m 277,403.3622 37.7728,-0.0912"
386+ inkscape:connector-curvature="0"
387+ sodipodi:nodetypes="cc" />
389+ sodipodi:nodetypes="cc"
390+ inkscape:connector-curvature="0"
392+ d="m 335,403.15739 37.8864,-0.31841"
393+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4203)"
394+ inkscape:export-xdpi="61.120499"
395+ inkscape:export-ydpi="61.120499" />
397+ inkscape:export-ydpi="61.120499"
398+ inkscape:export-xdpi="61.120499"
399+ xml:space="preserve"
400+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
404+ sodipodi:linespacing="125%"><tspan
405+ sodipodi:role="line"
408+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
409+ id="tspan4209">during elaboration</tspan><tspan
410+ sodipodi:role="line"
413+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
414+ id="tspan4213">may contain holes</tspan><tspan
415+ sodipodi:role="line"
418+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
419+ id="tspan4199">and guesses</tspan></text>
421+ inkscape:export-ydpi="61.120499"
422+ inkscape:export-xdpi="61.120499"
423+ sodipodi:nodetypes="cc"
424+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
425+ d="m 324,399.3622 0.11194,-38.03731"
427+ inkscape:connector-curvature="0" />
429+ sodipodi:linespacing="125%"
433+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
434+ xml:space="preserve"
435+ inkscape:export-xdpi="61.120499"
436+ inkscape:export-ydpi="61.120499"><tspan
438+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
441+ sodipodi:role="line">Make explicit all types.</tspan><tspan
443+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
446+ sodipodi:role="line">Make explicit function and </tspan><tspan
447+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
450+ sodipodi:role="line"
451+ id="tspan4235"> pattern match variables.</tspan></text>
453+ inkscape:export-ydpi="61.120499"
454+ inkscape:export-xdpi="61.120499"
455+ sodipodi:nodetypes="cc"
456+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
457+ d="m 323.7402,434.372 0.0637,16.14706"
459+ inkscape:connector-curvature="0" />
461+ inkscape:export-ydpi="61.120499"
462+ inkscape:export-xdpi="61.120499"
463+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker4198)"
464+ d="m 395,402.49819 45.38391,-0.31841"
466+ inkscape:connector-curvature="0"
467+ sodipodi:nodetypes="cc" />
469+ inkscape:export-ydpi="61.120499"
470+ inkscape:export-xdpi="61.120499"
471+ xml:space="preserve"
472+ style="font-style:normal;font-weight:normal;font-size:15px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
476+ sodipodi:linespacing="125%"><tspan
477+ sodipodi:role="line"
480+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
481+ id="tspan4204">type checker</tspan><tspan
482+ sodipodi:role="line"
485+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold'"
486+ id="tspan4208">Raw -> TT</tspan></text>
488+ inkscape:export-ydpi="61.120499"
489+ inkscape:export-xdpi="61.120499"
490+ sodipodi:nodetypes="cc"
491+ style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
492+ d="m 421,411.3622 39,40"
494+ inkscape:connector-curvature="0" />
496+ inkscape:export-ydpi="61.120499"
497+ inkscape:export-xdpi="61.120499"
498+ xml:space="preserve"
499+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
503+ sodipodi:linespacing="125%"><tspan
504+ sodipodi:role="line"
508+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000">Raw</tspan></text>
510+ sodipodi:linespacing="125%"
514+ style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
515+ xml:space="preserve"
516+ inkscape:export-xdpi="61.120499"
517+ inkscape:export-ydpi="61.120499"><tspan
518+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:15px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000"
522+ sodipodi:role="line">PTerm</tspan></text>
docs/image/login.pngnew file
Binary file not shown.
docs/image/netstate.pngnew file
Binary file not shown.
docs/image/parserModules.pngnew file
Binary file not shown.
docs/image/parserModules.svgnew file+1251
@@ -0,0 +1,1251 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 210 297"
17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"
18+ sodipodi:docname="parserModules.svg">
22+ inkscape:isstock="true"
23+ style="overflow:visible;"
28+ inkscape:stockid="Arrow1Mend">
30+ transform="scale(0.4) rotate(180) translate(10,0)"
31+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
32+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
36+ inkscape:isstock="true"
37+ style="overflow:visible"
42+ inkscape:stockid="Arrow1Mstart">
44+ transform="scale(0.4) translate(10,0)"
45+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
46+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
50+ inkscape:stockid="Arrow1Mend"
55+ style="overflow:visible;"
56+ inkscape:isstock="true"
57+ inkscape:collect="always">
60+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
61+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
62+ transform="scale(0.4) rotate(180) translate(10,0)" />
65+ inkscape:stockid="Arrow1Mstart"
70+ style="overflow:visible"
71+ inkscape:isstock="true"
72+ inkscape:collect="always">
75+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
76+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
77+ transform="scale(0.4) translate(10,0)" />
80+ inkscape:isstock="true"
81+ style="overflow:visible;"
86+ inkscape:stockid="Arrow1Mend"
87+ inkscape:collect="always">
89+ transform="scale(0.4) rotate(180) translate(10,0)"
90+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
91+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
95+ inkscape:isstock="true"
96+ style="overflow:visible"
101+ inkscape:stockid="Arrow1Mstart"
102+ inkscape:collect="always">
104+ transform="scale(0.4) translate(10,0)"
105+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
106+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
110+ inkscape:stockid="Arrow1Mend"
115+ style="overflow:visible;"
116+ inkscape:isstock="true"
117+ inkscape:collect="always">
120+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
121+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
122+ transform="scale(0.4) rotate(180) translate(10,0)" />
125+ inkscape:stockid="Arrow1Mstart"
130+ style="overflow:visible"
131+ inkscape:isstock="true"
132+ inkscape:collect="always">
135+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
136+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
137+ transform="scale(0.4) translate(10,0)" />
140+ inkscape:isstock="true"
141+ style="overflow:visible;"
146+ inkscape:stockid="Arrow1Mend">
148+ transform="scale(0.4) rotate(180) translate(10,0)"
149+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
150+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
154+ inkscape:isstock="true"
155+ style="overflow:visible;"
160+ inkscape:stockid="Arrow1Mend">
162+ transform="scale(0.4) rotate(180) translate(10,0)"
163+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
164+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
168+ inkscape:isstock="true"
169+ style="overflow:visible;"
174+ inkscape:stockid="Arrow1Mend">
176+ transform="scale(0.4) rotate(180) translate(10,0)"
177+ style="fill-rule:evenodd;stroke:#00aa3f;stroke-width:1pt;stroke-opacity:1;fill:#00aa3f;fill-opacity:1"
178+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
182+ inkscape:isstock="true"
183+ style="overflow:visible;"
188+ inkscape:stockid="Arrow1Mend">
190+ transform="scale(0.4) rotate(180) translate(10,0)"
191+ style="fill-rule:evenodd;stroke:#00aa3f;stroke-width:1pt;stroke-opacity:1;fill:#00aa3f;fill-opacity:1"
192+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
196+ inkscape:stockid="Arrow1Mend"
201+ style="overflow:visible;"
202+ inkscape:isstock="true"
203+ inkscape:collect="always">
206+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
207+ style="fill-rule:evenodd;stroke:#00aa3f;stroke-width:1pt;stroke-opacity:1;fill:#00aa3f;fill-opacity:1"
208+ transform="scale(0.4) rotate(180) translate(10,0)" />
211+ inkscape:isstock="true"
212+ style="overflow:visible;"
217+ inkscape:stockid="Arrow1Mend"
218+ inkscape:collect="always">
220+ transform="scale(0.4) rotate(180) translate(10,0)"
221+ style="fill-rule:evenodd;stroke:#00aa3f;stroke-width:1pt;stroke-opacity:1;fill:#00aa3f;fill-opacity:1"
222+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
226+ inkscape:isstock="true"
227+ style="overflow:visible;"
232+ inkscape:stockid="Arrow1Mend">
234+ transform="scale(0.4) rotate(180) translate(10,0)"
235+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
236+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
240+ inkscape:stockid="Arrow1Mend"
245+ style="overflow:visible;"
246+ inkscape:isstock="true"
247+ inkscape:collect="always">
250+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
251+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
252+ transform="scale(0.4) rotate(180) translate(10,0)" />
255+ inkscape:stockid="Arrow1Mend"
260+ style="overflow:visible;"
261+ inkscape:isstock="true">
264+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
265+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
266+ transform="scale(0.4) rotate(180) translate(10,0)" />
269+ inkscape:stockid="Arrow1Mend"
274+ style="overflow:visible;"
275+ inkscape:isstock="true">
278+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
279+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
280+ transform="scale(0.4) rotate(180) translate(10,0)" />
283+ inkscape:isstock="true"
284+ style="overflow:visible;"
289+ inkscape:stockid="Arrow1Mend"
290+ inkscape:collect="always">
292+ transform="scale(0.4) rotate(180) translate(10,0)"
293+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
294+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
298+ inkscape:isstock="true"
299+ style="overflow:visible;"
304+ inkscape:stockid="Arrow1Mend">
306+ transform="scale(0.4) rotate(180) translate(10,0)"
307+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
308+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
312+ inkscape:isstock="true"
313+ style="overflow:visible;"
318+ inkscape:stockid="Arrow1Mend">
320+ transform="scale(0.4) rotate(180) translate(10,0)"
321+ style="fill-rule:evenodd;stroke:#ff0000;stroke-width:1pt;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
322+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
326+ inkscape:stockid="Arrow1Mend"
331+ style="overflow:visible;"
332+ inkscape:isstock="true"
333+ inkscape:collect="always">
336+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
337+ style="fill-rule:evenodd;stroke:#ff0000;stroke-width:1pt;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
338+ transform="scale(0.4) rotate(180) translate(10,0)" />
341+ inkscape:isstock="true"
342+ style="overflow:visible;"
347+ inkscape:stockid="Arrow1Mend"
348+ inkscape:collect="always">
350+ transform="scale(0.4) rotate(180) translate(10,0)"
351+ style="fill-rule:evenodd;stroke:#ff0000;stroke-width:1pt;stroke-opacity:1;fill:#ff0000;fill-opacity:1"
352+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
356+ inkscape:stockid="Arrow1Mend"
361+ style="overflow:visible;"
362+ inkscape:isstock="true"
363+ inkscape:collect="always">
366+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
367+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
368+ transform="scale(0.4) rotate(180) translate(10,0)" />
371+ inkscape:isstock="true"
372+ style="overflow:visible;"
377+ inkscape:stockid="Arrow1Mend"
378+ inkscape:collect="always">
380+ transform="scale(0.4) rotate(180) translate(10,0)"
381+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
382+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
386+ inkscape:isstock="true"
387+ style="overflow:visible;"
392+ inkscape:stockid="Arrow1Mend">
394+ transform="scale(0.4) rotate(180) translate(10,0)"
395+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
396+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
400+ inkscape:stockid="Arrow1Mend"
405+ style="overflow:visible;"
406+ inkscape:isstock="true"
407+ inkscape:collect="always">
410+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
411+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
412+ transform="scale(0.4) rotate(180) translate(10,0)" />
415+ inkscape:isstock="true"
416+ style="overflow:visible;"
421+ inkscape:stockid="Arrow1Mend"
422+ inkscape:collect="always">
424+ transform="scale(0.4) rotate(180) translate(10,0)"
425+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
426+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
433+ bordercolor="#666666"
435+ inkscape:pageopacity="0.0"
436+ inkscape:pageshadow="2"
438+ inkscape:cx="368.33949"
439+ inkscape:cy="547.05121"
440+ inkscape:document-units="mm"
441+ inkscape:current-layer="layer1"
443+ inkscape:window-width="1800"
444+ inkscape:window-height="1011"
445+ inkscape:window-x="86"
446+ inkscape:window-y="0"
447+ inkscape:window-maximized="0"
448+ inkscape:snap-nodes="false" />
454+ <dc:format>image/svg+xml</dc:format>
456+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
462+ inkscape:label="Layer 1"
463+ inkscape:groupmode="layer"
466+ inkscape:export-ydpi="61.120499"
467+ inkscape:export-xdpi="61.120499"
471+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
472+ xml:space="preserve"><tspan
473+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
477+ sodipodi:role="line" /></text>
479+ inkscape:export-ydpi="61.120499"
480+ inkscape:export-xdpi="61.120499"
481+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
488+ inkscape:export-ydpi="61.120499"
489+ inkscape:export-xdpi="61.120499"
490+ inkscape:connector-curvature="0"
492+ d="m 135.73129,118.93554 16.66875,-0.26459"
493+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker2049)" />
495+ inkscape:export-ydpi="61.120499"
496+ inkscape:export-xdpi="61.120499"
500+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
501+ xml:space="preserve"><tspan
502+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
506+ sodipodi:role="line">PTerm</tspan></text>
508+ inkscape:export-ydpi="61.120499"
509+ inkscape:export-xdpi="61.120499"
513+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
514+ xml:space="preserve"><tspan
515+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332"
519+ sodipodi:role="line">module Idris.Parser</tspan><tspan
520+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332"
523+ sodipodi:role="line"
524+ id="tspan1021" /></text>
526+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
532+ inkscape:export-xdpi="61.120499"
533+ inkscape:export-ydpi="61.120499" />
540+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
541+ inkscape:export-xdpi="61.120499"
542+ inkscape:export-ydpi="61.120499" />
544+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker961)"
545+ d="m 84.648837,152.88468 9.013662,7.32603"
547+ inkscape:connector-curvature="0"
548+ inkscape:export-xdpi="61.120499"
549+ inkscape:export-ydpi="61.120499"
550+ sodipodi:nodetypes="cc" />
552+ inkscape:connector-curvature="0"
554+ d="m 22.471756,152.09108 16.66875,-0.26459"
555+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1539)"
556+ inkscape:export-xdpi="61.120499"
557+ inkscape:export-ydpi="61.120499" />
559+ xml:space="preserve"
560+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
564+ inkscape:export-xdpi="61.120499"
565+ inkscape:export-ydpi="61.120499"><tspan
566+ sodipodi:role="line"
570+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332">String</tspan></text>
575+ style="font-style:normal;font-weight:normal;font-size:4.23333311px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
576+ xml:space="preserve"
577+ inkscape:export-xdpi="61.120499"
578+ inkscape:export-ydpi="61.120499"><tspan
579+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
582+ sodipodi:role="line"
583+ id="tspan921">List (TokenData Token)</tspan></text>
588+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
589+ xml:space="preserve"
590+ inkscape:export-xdpi="61.120499"
591+ inkscape:export-ydpi="61.120499"><tspan
592+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332;"
596+ sodipodi:role="line">module Text.Lexer</tspan></text>
598+ xml:space="preserve"
599+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
603+ inkscape:export-xdpi="61.120499"
604+ inkscape:export-ydpi="61.120499"><tspan
605+ sodipodi:role="line"
609+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332">module Parser.Support</tspan></text>
611+ inkscape:export-ydpi="61.120499"
612+ inkscape:export-xdpi="61.120499"
618+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
620+ inkscape:export-ydpi="61.120499"
621+ inkscape:export-xdpi="61.120499"
622+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
629+ inkscape:export-ydpi="61.120499"
630+ inkscape:export-xdpi="61.120499"
631+ xml:space="preserve"
632+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
636+ sodipodi:role="line"
640+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332">module Parser.Lexer</tspan></text>
642+ sodipodi:nodetypes="cc"
643+ inkscape:export-ydpi="61.120499"
644+ inkscape:export-xdpi="61.120499"
645+ inkscape:connector-curvature="0"
647+ d="m 53.299561,213.22831 1.53604,-51.85834"
648+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker967)" />
650+ inkscape:export-ydpi="61.120499"
651+ inkscape:export-xdpi="61.120499"
652+ xml:space="preserve"
653+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
657+ sodipodi:role="line"
661+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332;">module Text.Lexer.Core</tspan></text>
663+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
669+ inkscape:export-xdpi="61.120499"
670+ inkscape:export-ydpi="61.120499" />
672+ style="fill:none;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker991)"
673+ d="m 48.369316,228.83873 0.04943,-6.71548"
675+ inkscape:connector-curvature="0"
676+ inkscape:export-xdpi="61.120499"
677+ inkscape:export-ydpi="61.120499"
678+ sodipodi:nodetypes="cc" />
683+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
684+ xml:space="preserve"
685+ inkscape:export-xdpi="61.120499"
686+ inkscape:export-ydpi="61.120499"><tspan
687+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332;"
691+ sodipodi:role="line">module Text.Quantity</tspan></text>
693+ inkscape:export-ydpi="61.120499"
694+ inkscape:export-xdpi="61.120499"
700+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
702+ inkscape:export-ydpi="61.120499"
703+ inkscape:export-xdpi="61.120499"
704+ xml:space="preserve"
705+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
709+ sodipodi:role="line"
713+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332;">module Text.Token</tspan></text>
715+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
721+ inkscape:export-xdpi="61.120499"
722+ inkscape:export-ydpi="61.120499" />
724+ sodipodi:nodetypes="cc"
725+ inkscape:export-ydpi="61.120499"
726+ inkscape:export-xdpi="61.120499"
727+ inkscape:connector-curvature="0"
729+ d="M 62.998384,237.01083 62.846037,221.92147"
730+ style="fill:#ff0000;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker997)" />
732+ style="fill:#ff0000;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1003)"
733+ d="M 67.336659,246.29272 67.083422,221.71969"
735+ inkscape:connector-curvature="0"
736+ inkscape:export-xdpi="61.120499"
737+ inkscape:export-ydpi="61.120499"
738+ sodipodi:nodetypes="cc" />
740+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1009)"
741+ d="M 73.937074,214.02206 94.72083,169.47102"
743+ inkscape:connector-curvature="0"
744+ inkscape:export-xdpi="61.120499"
745+ inkscape:export-ydpi="61.120499"
746+ sodipodi:nodetypes="cc" />
748+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1015)"
749+ d="M 108.0684,213.75748 108.0169,173.5408"
751+ inkscape:connector-curvature="0"
752+ inkscape:export-xdpi="61.120499"
753+ inkscape:export-ydpi="61.120499"
754+ sodipodi:nodetypes="cc" />
756+ inkscape:export-ydpi="61.120499"
757+ inkscape:export-xdpi="61.120499"
761+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
762+ xml:space="preserve"><tspan
763+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332;"
767+ sodipodi:role="line">module Text.Parser</tspan></text>
769+ sodipodi:nodetypes="cc"
770+ inkscape:export-ydpi="61.120499"
771+ inkscape:export-xdpi="61.120499"
772+ inkscape:connector-curvature="0"
774+ d="m 113.62466,154.75539 0.0397,-25.06978"
775+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1027)" />
777+ sodipodi:nodetypes="cc"
778+ inkscape:export-ydpi="61.120499"
779+ inkscape:export-xdpi="61.120499"
780+ inkscape:connector-curvature="0"
782+ d="M 83.757032,147.15485 97.991855,129.77582"
783+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1033)" />
790+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
791+ inkscape:export-xdpi="61.120499"
792+ inkscape:export-ydpi="61.120499" />
794+ sodipodi:nodetypes="cc"
795+ inkscape:export-ydpi="61.120499"
796+ inkscape:export-xdpi="61.120499"
797+ inkscape:connector-curvature="0"
799+ d="m 121.83513,142.5835 -0.0515,-12.72267"
800+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1057)" />
802+ xml:space="preserve"
803+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
807+ inkscape:export-xdpi="61.120499"
808+ inkscape:export-ydpi="61.120499"><tspan
809+ sodipodi:role="line"
813+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332">module TTImp.TTImp</tspan></text>
815+ inkscape:export-ydpi="61.120499"
816+ inkscape:export-xdpi="61.120499"
817+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
824+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1045)"
825+ d="m 145.18016,132.82376 -9.18434,-4.09859"
827+ inkscape:connector-curvature="0"
828+ inkscape:export-xdpi="61.120499"
829+ inkscape:export-ydpi="61.120499"
830+ sodipodi:nodetypes="cc" />
832+ inkscape:export-ydpi="61.120499"
833+ inkscape:export-xdpi="61.120499"
837+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
838+ xml:space="preserve"><tspan
839+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332"
843+ sodipodi:role="line">module Idris.Syntax</tspan></text>
845+ inkscape:export-ydpi="61.120499"
846+ inkscape:export-xdpi="61.120499"
847+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#00871c;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
854+ inkscape:export-ydpi="61.120499"
855+ inkscape:export-xdpi="61.120499"
856+ inkscape:connector-curvature="0"
858+ d="m 76.993749,160.21044 18.785417,28.83958"
859+ style="fill:none;stroke:#00aa3f;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1105)"
860+ sodipodi:nodetypes="cc" />
862+ inkscape:export-ydpi="61.120499"
863+ inkscape:export-xdpi="61.120499"
867+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#008000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
868+ xml:space="preserve"><tspan
869+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#008000;stroke-width:0.26458332"
873+ sodipodi:role="line">SExp</tspan></text>
875+ inkscape:export-ydpi="61.120499"
876+ inkscape:export-xdpi="61.120499"
880+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#008000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
881+ xml:space="preserve"><tspan
882+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#008000;stroke-width:0.26458332"
886+ sodipodi:role="line">module Idris.IDEMode.Parser</tspan></text>
888+ inkscape:export-ydpi="61.120499"
889+ inkscape:export-xdpi="61.120499"
890+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#7c007d;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
897+ inkscape:export-ydpi="61.120499"
898+ inkscape:export-xdpi="61.120499"
902+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#800080;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
903+ xml:space="preserve"><tspan
904+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#800080;stroke-width:0.26458332;"
908+ sodipodi:role="line">module Idris.REPL</tspan></text>
910+ sodipodi:nodetypes="cc"
911+ style="fill:none;stroke:#00aa3f;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1111)"
912+ d="m 112.97708,174.23335 0,14.02292"
914+ inkscape:connector-curvature="0"
915+ inkscape:export-xdpi="61.120499"
916+ inkscape:export-ydpi="61.120499" />
918+ inkscape:export-ydpi="61.120499"
919+ inkscape:export-xdpi="61.120499"
920+ inkscape:connector-curvature="0"
922+ d="m 148.43125,150.15592 0.26458,35.71911"
923+ style="fill:none;stroke:#00aa3f;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1117)"
924+ sodipodi:nodetypes="cc" />
926+ inkscape:export-ydpi="61.120499"
927+ inkscape:export-xdpi="61.120499"
928+ inkscape:connector-curvature="0"
930+ d="m 156.56889,195.56696 13.16435,-0.41532"
931+ style="fill:none;stroke:#00aa3f;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1123)"
932+ sodipodi:nodetypes="cc" />
937+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
938+ xml:space="preserve"
939+ inkscape:export-xdpi="61.120499"
940+ inkscape:export-ydpi="61.120499"><tspan
941+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332"
945+ sodipodi:role="line">module Core.Core</tspan></text>
947+ inkscape:export-ydpi="61.120499"
948+ inkscape:export-xdpi="61.120499"
954+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
956+ inkscape:export-ydpi="61.120499"
957+ inkscape:export-xdpi="61.120499"
958+ xml:space="preserve"
959+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
963+ sodipodi:role="line"
967+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:3.52777767px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332">error messages</tspan></text>
969+ inkscape:export-ydpi="61.120499"
970+ inkscape:export-xdpi="61.120499"
971+ xml:space="preserve"
972+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
976+ sodipodi:role="line"
980+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332">module Core.CompileExpr</tspan></text>
982+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
988+ inkscape:export-xdpi="61.120499"
989+ inkscape:export-ydpi="61.120499" />
994+ style="font-style:normal;font-weight:normal;font-size:3.52777767px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
995+ xml:space="preserve"
996+ inkscape:export-xdpi="61.120499"
997+ inkscape:export-ydpi="61.120499"><tspan
998+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:3.52777767px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332"
1001+ sodipodi:role="line"
1002+ id="tspan968">Representation of expressions ready</tspan><tspan
1003+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:3.52777767px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332"
1006+ sodipodi:role="line"
1007+ id="tspan974">for compiling: CExp</tspan><tspan
1008+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:3.52777767px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332"
1011+ sodipodi:role="line"
1012+ id="tspan972">Type erased, explicit case trees</tspan></text>
1014+ inkscape:export-ydpi="61.120499"
1015+ inkscape:export-xdpi="61.120499"
1016+ xml:space="preserve"
1017+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
1020+ id="text978"><tspan
1021+ sodipodi:role="line"
1025+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332">module Idris.CommandLine</tspan></text>
1027+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
1033+ inkscape:export-xdpi="61.120499"
1034+ inkscape:export-ydpi="61.120499" />
1039+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
1040+ xml:space="preserve"
1041+ inkscape:export-xdpi="61.120499"
1042+ inkscape:export-ydpi="61.120499"><tspan
1043+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:3.52777767px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332"
1047+ sodipodi:role="line">command line options</tspan></text>
1052+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
1053+ xml:space="preserve"
1054+ inkscape:export-xdpi="61.120499"
1055+ inkscape:export-ydpi="61.120499"><tspan
1056+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332"
1060+ sodipodi:role="line">module Idris.Error</tspan></text>
1062+ inkscape:export-ydpi="61.120499"
1063+ inkscape:export-xdpi="61.120499"
1069+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
1071+ inkscape:export-ydpi="61.120499"
1072+ inkscape:export-xdpi="61.120499"
1073+ xml:space="preserve"
1074+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
1077+ id="text994"><tspan
1078+ sodipodi:role="line"
1082+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:3.52777767px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332">perror</tspan></text>
1084+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1000)"
1085+ d="m 66.876776,99.410007 c -0.17822,-10.50534 -0.880145,-7.9985 -7.143748,-8.99444"
1087+ inkscape:connector-curvature="0"
1088+ inkscape:export-xdpi="61.120499"
1089+ inkscape:export-ydpi="61.120499"
1090+ sodipodi:nodetypes="cc" />
1092+ style="fill:none;stroke:#000000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
1093+ d="M 15.081249,210.48125 H 200.02499"
1095+ inkscape:connector-curvature="0"
1096+ sodipodi:nodetypes="cc"
1097+ inkscape:export-xdpi="61.120499"
1098+ inkscape:export-ydpi="61.120499" />
1100+ style="fill:none;stroke:#000000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none;marker-start:url(#Arrow1Mstart);marker-end:url(#Arrow1Mend)"
1101+ d="m 154.78125,214.97917 -0.26459,40.21666"
1103+ inkscape:connector-curvature="0"
1104+ inkscape:export-xdpi="61.120499"
1105+ inkscape:export-ydpi="61.120499" />
1107+ xml:space="preserve"
1108+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:0.40000001;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
1112+ inkscape:export-xdpi="61.120499"
1113+ inkscape:export-ydpi="61.120499"><tspan
1114+ sodipodi:role="line"
1118+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332;">'text' modules are</tspan><tspan
1119+ sodipodi:role="line"
1122+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332;"
1123+ id="tspan1475">also in Idris 1</tspan><tspan
1124+ sodipodi:role="line"
1127+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff0000;stroke-width:0.26458332;"
1128+ id="tspan1477">library.</tspan></text>
1130+ inkscape:connector-curvature="0"
1132+ d="m 172.77292,166.03125 -0.26459,40.21666"
1133+ style="fill:none;stroke:#000000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker969);marker-end:url(#marker973)"
1134+ inkscape:export-xdpi="61.120499"
1135+ inkscape:export-ydpi="61.120499" />
1137+ inkscape:export-ydpi="61.120499"
1138+ inkscape:export-xdpi="61.120499"
1142+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:0.40000001;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#008000;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
1143+ xml:space="preserve"><tspan
1145+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#008000;stroke-width:0.26458332;"
1148+ sodipodi:role="line">'IDEMode is for</tspan><tspan
1149+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#008000;stroke-width:0.26458332;"
1152+ sodipodi:role="line"
1153+ id="tspan981">communicating</tspan><tspan
1154+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#008000;stroke-width:0.26458332;"
1157+ sodipodi:role="line"
1158+ id="tspan984">with external</tspan><tspan
1159+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#008000;stroke-width:0.26458332;"
1162+ sodipodi:role="line"
1163+ id="tspan987">editors. It uses</tspan><tspan
1164+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#008000;stroke-width:0.26458332;"
1167+ sodipodi:role="line"
1168+ id="tspan989">SExp structure</tspan><tspan
1169+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#008000;stroke-width:0.26458332;"
1172+ sodipodi:role="line"
1173+ id="tspan991">which is Lisp-</tspan><tspan
1174+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#008000;stroke-width:0.26458332;"
1177+ sodipodi:role="line"
1178+ id="tspan993">like.</tspan></text>
1180+ style="fill:none;stroke:#000000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker1017);marker-end:url(#marker1021)"
1181+ d="m 172.77292,110.20417 -0.26459,40.21666"
1183+ inkscape:connector-curvature="0"
1184+ inkscape:export-xdpi="61.120499"
1185+ inkscape:export-ydpi="61.120499" />
1187+ xml:space="preserve"
1188+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:0.40000001;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
1192+ inkscape:export-xdpi="61.120499"
1193+ inkscape:export-ydpi="61.120499"><tspan
1195+ sodipodi:role="line"
1198+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332">Idris.Parser</tspan><tspan
1199+ sodipodi:role="line"
1202+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332"
1203+ id="tspan1050">reads from a</tspan><tspan
1204+ sodipodi:role="line"
1207+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332"
1208+ id="tspan1052">file and outputs</tspan><tspan
1209+ sodipodi:role="line"
1212+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332"
1213+ id="tspan1054">to a PTerm</tspan><tspan
1214+ sodipodi:role="line"
1217+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#000000;stroke-width:0.26458332"
1218+ id="tspan1056">structure.</tspan></text>
1220+ inkscape:connector-curvature="0"
1222+ d="m 171.97917,51.731253 -0.26459,19.57916"
1223+ style="fill:none;stroke:#000000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-start:url(#marker1074);marker-end:url(#marker1078)"
1224+ sodipodi:nodetypes="cc"
1225+ inkscape:export-xdpi="61.120499"
1226+ inkscape:export-ydpi="61.120499" />
1228+ inkscape:export-ydpi="61.120499"
1229+ inkscape:export-xdpi="61.120499"
1233+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:0.40000001;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#800080;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
1234+ xml:space="preserve"><tspan
1235+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#800080;stroke-width:0.26458332;"
1238+ sodipodi:role="line"
1239+ id="tspan1060">Idris.Parser</tspan><tspan
1241+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#800080;stroke-width:0.26458332;"
1244+ sodipodi:role="line">reads from the</tspan><tspan
1245+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:0.40000001;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#800080;stroke-width:0.26458332;"
1248+ sodipodi:role="line"
1249+ id="tspan1089">command line.</tspan></text>
docs/image/parserTopLevel.pngnew file
Binary file not shown.
docs/image/parserTopLevel.svgnew file+294
@@ -0,0 +1,294 @@
1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2+<!-- Created with Inkscape (http://www.inkscape.org/) -->
5+ xmlns:dc="http://purl.org/dc/elements/1.1/"
6+ xmlns:cc="http://creativecommons.org/ns#"
7+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
8+ xmlns:svg="http://www.w3.org/2000/svg"
9+ xmlns="http://www.w3.org/2000/svg"
10+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
11+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
14+ viewBox="0 0 210 297"
17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"
18+ sodipodi:docname="topLevel.svg">
22+ inkscape:isstock="true"
23+ style="overflow:visible;"
28+ inkscape:stockid="Arrow1Mend">
30+ transform="scale(0.4) rotate(180) translate(10,0)"
31+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
32+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
36+ inkscape:stockid="Arrow1Mend"
41+ style="overflow:visible;"
42+ inkscape:isstock="true"
43+ inkscape:collect="always">
46+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
47+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
48+ transform="scale(0.4) rotate(180) translate(10,0)" />
51+ inkscape:stockid="Arrow1Mend"
56+ style="overflow:visible;"
57+ inkscape:isstock="true">
60+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
61+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
62+ transform="scale(0.4) rotate(180) translate(10,0)" />
65+ inkscape:isstock="true"
66+ style="overflow:visible;"
71+ inkscape:stockid="Arrow1Mend"
72+ inkscape:collect="always">
74+ transform="scale(0.4) rotate(180) translate(10,0)"
75+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
76+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
80+ inkscape:stockid="Arrow1Mend"
85+ style="overflow:visible;"
86+ inkscape:isstock="true"
87+ inkscape:collect="always">
90+ d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
91+ style="fill-rule:evenodd;stroke:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;fill-opacity:1"
92+ transform="scale(0.4) rotate(180) translate(10,0)" />
98+ bordercolor="#666666"
100+ inkscape:pageopacity="0.0"
101+ inkscape:pageshadow="2"
103+ inkscape:cx="396.85039"
105+ inkscape:document-units="mm"
106+ inkscape:current-layer="layer1"
108+ inkscape:window-width="1920"
109+ inkscape:window-height="1015"
110+ inkscape:window-x="0"
111+ inkscape:window-y="0"
112+ inkscape:window-maximized="1" />
118+ <dc:format>image/svg+xml</dc:format>
120+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
126+ inkscape:label="Layer 1"
127+ inkscape:groupmode="layer"
130+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
136+ inkscape:export-xdpi="61.120499"
137+ inkscape:export-ydpi="61.120499" />
144+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
145+ inkscape:export-xdpi="61.120499"
146+ inkscape:export-ydpi="61.120499" />
148+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow1Mend)"
149+ d="m 73.554166,88.508337 16.66875,-0.26459"
151+ inkscape:connector-curvature="0"
152+ inkscape:export-xdpi="61.120499"
153+ inkscape:export-ydpi="61.120499" />
155+ inkscape:connector-curvature="0"
157+ d="m 18.785416,88.77292 16.66875,-0.26459"
158+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker1539)"
159+ inkscape:export-xdpi="61.120499"
160+ inkscape:export-ydpi="61.120499" />
162+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker2049)"
163+ d="m 128.32291,88.243753 16.66875,-0.26459"
165+ inkscape:connector-curvature="0"
166+ inkscape:export-xdpi="61.120499"
167+ inkscape:export-ydpi="61.120499" />
169+ xml:space="preserve"
170+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
174+ inkscape:export-xdpi="61.120499"
175+ inkscape:export-ydpi="61.120499"><tspan
176+ sodipodi:role="line"
180+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332">String</tspan></text>
185+ style="font-style:normal;font-weight:normal;font-size:4.23333311px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
186+ xml:space="preserve"
187+ inkscape:export-xdpi="61.120499"
188+ inkscape:export-ydpi="61.120499"><tspan
189+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
192+ sodipodi:role="line"
193+ id="tspan2867">List</tspan><tspan
194+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
197+ sodipodi:role="line"
198+ id="tspan2871">Token</tspan></text>
200+ xml:space="preserve"
201+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
205+ inkscape:export-xdpi="61.120499"
206+ inkscape:export-ydpi="61.120499"><tspan
207+ sodipodi:role="line"
211+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332">PTerm</tspan></text>
216+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332;"
217+ xml:space="preserve"
218+ inkscape:export-xdpi="61.120499"
219+ inkscape:export-ydpi="61.120499"><tspan
220+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332;fill:#0000ff;"
224+ sodipodi:role="line">Lexer</tspan></text>
226+ xml:space="preserve"
227+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#0000ff;fill-opacity:1;stroke:none;stroke-width:0.26458332"
231+ inkscape:export-xdpi="61.120499"
232+ inkscape:export-ydpi="61.120499"><tspan
233+ sodipodi:role="line"
237+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332">Parser</tspan></text>
239+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker2891)"
240+ d="m 52.916666,71.575003 v 7.67291"
242+ inkscape:connector-curvature="0"
243+ sodipodi:nodetypes="cc"
244+ inkscape:export-xdpi="61.120499"
245+ inkscape:export-ydpi="61.120499" />
247+ sodipodi:nodetypes="cc"
248+ inkscape:connector-curvature="0"
250+ d="m 108.74375,71.575003 v 7.67291"
251+ style="fill:none;stroke:#0000ff;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#marker3617)"
252+ inkscape:export-xdpi="61.120499"
253+ inkscape:export-ydpi="61.120499" />
258+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
259+ xml:space="preserve"
260+ inkscape:export-xdpi="61.120499"
261+ inkscape:export-ydpi="61.120499"><tspan
262+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
266+ sodipodi:role="line">Recogniser</tspan></text>
268+ xml:space="preserve"
269+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
273+ inkscape:export-xdpi="61.120499"
274+ inkscape:export-ydpi="61.120499"><tspan
275+ sodipodi:role="line"
279+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332">Grammar</tspan></text>
281+ inkscape:export-ydpi="61.120499"
282+ inkscape:export-xdpi="61.120499"
286+ style="font-style:normal;font-weight:normal;font-size:10.58333302px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
287+ xml:space="preserve"><tspan
288+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.26458332"
292+ sodipodi:role="line" /></text>
docs/image/plusReducesProof.pngnew file
Binary file not shown.
docs/image/plusReducesProof.svgnew file+339
This diff is too big to show here.
docs/image/recogniser.pngnew file
Binary file not shown.
docs/image/recogniser.svgnew file+477
This diff is too big to show here.
docs/image/solve.pngnew file
Binary file not shown.
docs/image/solve.svgnew file+163
This diff is too big to show here.
docs/image/tokenise.pngnew file
Binary file not shown.
docs/image/tokenise.svgnew file+740
This diff is too big to show here.
docs/image/tree.pngnew file
Binary file not shown.
docs/image/tree.svgnew file+212
This diff is too big to show here.
docs/index.rstnew file+30
This diff is too big to show here.
docs/listing/idris-prompt-helloworld.txtnew file+15
This diff is too big to show here.
docs/listing/idris-prompt-interp.txtnew file+12
This diff is too big to show here.
docs/listing/idris-prompt-start.txtnew file+8
This diff is too big to show here.
docs/make.batnew file+263
This diff is too big to show here.
docs/parserLibrary/index.rstnew file+24
This diff is too big to show here.
docs/parserLibrary/introduction.rstnew file+76
This diff is too big to show here.
docs/parserLibrary/lexer.rstnew file+288
This diff is too big to show here.
docs/parserLibrary/parser.rstnew file+700
This diff is too big to show here.
docs/parserLibrary/whitespace.rstnew file+250
This diff is too big to show here.
docs/proofs/definitional.rstnew file+235
This diff is too big to show here.
docs/proofs/index.rstnew file+28
This diff is too big to show here.
docs/proofs/inductive.rstnew file+101
This diff is too big to show here.
docs/proofs/interactive.rstnew file+296
This diff is too big to show here.
docs/proofs/interactiveOld.rstnew file+169
This diff is too big to show here.
docs/proofs/patterns.rstnew file+351
This diff is too big to show here.
docs/proofs/pluscomm.rstnew file+189
This diff is too big to show here.
docs/proofs/propositional.rstnew file+133
This diff is too big to show here.
docs/reference/codegen.rstnew file+147
This diff is too big to show here.
docs/reference/compilation.rstnew file+131
This diff is too big to show here.
docs/reference/documenting.rstnew file+142
This diff is too big to show here.
docs/reference/erasure.rstnew file+502
This diff is too big to show here.
docs/reference/ffi.rstnew file+534
This diff is too big to show here.
docs/reference/ide-protocol.rstnew file+213
This diff is too big to show here.
docs/reference/index.rstnew file+41
This diff is too big to show here.
docs/reference/internals.rstnew file+179
This diff is too big to show here.
docs/reference/language-extensions.rstnew file+41
This diff is too big to show here.
docs/reference/language-features.rstnew file+54
This diff is too big to show here.
docs/reference/misc.rstnew file+228
This diff is too big to show here.
docs/reference/packages.rstnew file+150
This diff is too big to show here.
docs/reference/partial-evaluation.rstnew file+305
This diff is too big to show here.
docs/reference/repl.rstnew file+546
This diff is too big to show here.
docs/reference/semantic-highlighting.rstnew file+50
This diff is too big to show here.
docs/reference/syntax-guide.rstnew file+489
This diff is too big to show here.
docs/reference/syntax-reference.rstnew file+422
This diff is too big to show here.
docs/reference/tactics.rstnew file+204
This diff is too big to show here.
docs/reference/type-directed-search.rstnew file+336
This diff is too big to show here.
docs/reference/uniqueness-types.rstnew file+252
This diff is too big to show here.
docs/st/composing.rstnew file+774
This diff is too big to show here.
docs/st/examples.rstnew file+439
This diff is too big to show here.
docs/st/index.rstnew file+27
This diff is too big to show here.
docs/st/introduction.rstnew file+93
This diff is too big to show here.
docs/st/machines.rstnew file+536
This diff is too big to show here.
docs/st/state.rstnew file+654
This diff is too big to show here.
docs/tutorial/conclusions.rstnew file+54
This diff is too big to show here.
docs/tutorial/index.rstnew file+37
This diff is too big to show here.
docs/tutorial/interactive.rstnew file+257
This diff is too big to show here.
docs/tutorial/interfaces.rstnew file+633
This diff is too big to show here.
docs/tutorial/interp.rstnew file+300
This diff is too big to show here.
docs/tutorial/introduction.rstnew file+74
This diff is too big to show here.
docs/tutorial/miscellany.rstnew file+589
This diff is too big to show here.
docs/tutorial/modules.rstnew file+274
This diff is too big to show here.
docs/tutorial/packages.rstnew file+185
This diff is too big to show here.
docs/tutorial/provisional.rstnew file+277
This diff is too big to show here.
docs/tutorial/starting.rstnew file+93
This diff is too big to show here.
docs/tutorial/syntax.rstnew file+211
This diff is too big to show here.
docs/tutorial/theorems.rstnew file+430
This diff is too big to show here.
docs/tutorial/typesfuns.rstnew file+1350
This diff is too big to show here.
docs/tutorial/views.rstnew file+156
This diff is too big to show here.
examples/binary.idrdeleted−62
This diff is too big to show here.
examples/views.idrdeleted−37
This diff is too big to show here.
icons/idris-128x128.pngnew file
Binary file not shown.
icons/idris-256x256.pngnew file
Binary file not shown.
icons/idris-48x48.pngnew file
Binary file not shown.
icons/idris-512x512.pngnew file
Binary file not shown.
icons/idris-64x64.pngnew file
Binary file not shown.
icons/idris_icon.rcnew file+1
This diff is too big to show here.
icons/text-x-idris.svgnew file+85
This diff is too big to show here.
icons/x-idris-bytecode.xmlnew file+4
This diff is too big to show here.
icons/x-idris-literate.xmlnew file+4
This diff is too big to show here.
icons/x-idris.xmlnew file+4
This diff is too big to show here.
This diff is too big to show here.
idrisdoc/styles.cssnew file+320
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
iif/testmap.iifdeleted−30
This diff is too big to show here.
This diff is too big to show here.
jsrts/Runtime-browser.jsdeleted−3
This diff is too big to show here.
jsrts/Runtime-common.js+21−38
This diff is too big to show here.
jsrts/Runtime-javascript.jsnew file+15
This diff is too big to show here.
jsrts/Runtime-node.js+40−6
This diff is too big to show here.
jsrts/jsbn/jsbn-browser.jsnew file+1353
This diff is too big to show here.
jsrts/jsbn/jsbn-node.jsnew file+1
This diff is too big to show here.
jsrts/jsbn/jsbn.jsdeleted−1235
This diff is too big to show here.
This diff is too big to show here.
libs/base/Control/Arrow.idr+70−10
This diff is too big to show here.
libs/base/Control/Catchable.idr+36−11
This diff is too big to show here.
libs/base/Control/Category.idr+8−6
This diff is too big to show here.
libs/base/Control/IOExcept.idr+20−24
This diff is too big to show here.
libs/base/Control/Isomorphism.idr+121−91
This diff is too big to show here.
libs/base/Control/Monad/Identity.idr+29−7
This diff is too big to show here.
libs/base/Control/Monad/RWS.idr+50−41
This diff is too big to show here.
libs/base/Control/Monad/Reader.idr+24−13
This diff is too big to show here.
libs/base/Control/Monad/State.idr+50−22
This diff is too big to show here.
libs/base/Control/Monad/Trans.idrnew file+6
This diff is too big to show here.
libs/base/Control/Monad/Writer.idr+35−18
This diff is too big to show here.
libs/base/Data/Bits.idr+173−105
This diff is too big to show here.
libs/base/Data/BoundedList.idrdeleted−92
This diff is too big to show here.
libs/base/Data/Buffer.idr+168−250
This diff is too big to show here.
libs/base/Data/Complex.idr+33−27
This diff is too big to show here.
libs/base/Data/Erased.idrnew file+29
This diff is too big to show here.
libs/base/Data/Fin.idrnew file+221
This diff is too big to show here.
libs/base/Data/Floats.idrdeleted−59
This diff is too big to show here.
libs/base/Data/Fun.idrdeleted−8
This diff is too big to show here.
libs/base/Data/HVect.idr+83−57
This diff is too big to show here.
libs/base/Data/IORef.idrnew file+61
This diff is too big to show here.
libs/base/Data/List.idrnew file+74
This diff is too big to show here.
libs/base/Data/List/Quantifiers.idrnew file+82
This diff is too big to show here.
libs/base/Data/List/Views.idrnew file+223
This diff is too big to show here.
libs/base/Data/Mod2.idr+15−17
This diff is too big to show here.
libs/base/Data/Morphisms.idr+54−26
This diff is too big to show here.
libs/base/Data/Nat/Views.idrnew file+34
This diff is too big to show here.
libs/base/Data/Primitives/Views.idrnew file+81
This diff is too big to show here.
libs/base/Data/Sign.idrdeleted−6
This diff is too big to show here.
libs/base/Data/So.idrnew file+36
This diff is too big to show here.
libs/base/Data/SortedSet.idrdeleted−25
This diff is too big to show here.
libs/base/Data/String.idrnew file+114
This diff is too big to show here.
libs/base/Data/String/Views.idrnew file+15
This diff is too big to show here.
libs/base/Data/Vect.idr+1031−8
This diff is too big to show here.
libs/base/Data/Vect/Quantifiers.idr+36−6
This diff is too big to show here.
libs/base/Data/Vect/Views.idrnew file+83
This diff is too big to show here.
libs/base/Data/ZZ.idrdeleted−144
This diff is too big to show here.
libs/base/Debug/Error.idrnew file+17
This diff is too big to show here.
libs/base/Debug/Trace.idr+6−2
This diff is too big to show here.
libs/base/Decidable/Order.idrdeleted−78
This diff is too big to show here.
libs/base/Language/Reflection.idrdeleted−199
This diff is too big to show here.
libs/base/Language/Reflection/Utils.idr+308−174
This diff is too big to show here.
This diff is too big to show here.
libs/base/Network/Socket.idrdeleted−246
This diff is too big to show here.
libs/base/Providers.idrdeleted−19
This diff is too big to show here.
libs/base/Syntax/PreorderReasoning.idr+5−3
This diff is too big to show here.
libs/base/System.idr+73−34
This diff is too big to show here.
libs/base/System/Concurrency/Channels.idrnew file+70
This diff is too big to show here.
libs/base/System/Concurrency/Process.idrdeleted−68
This diff is too big to show here.
libs/base/System/Concurrency/Raw.idr+100−14
This diff is too big to show here.
libs/base/System/Info.idrnew file+16
This diff is too big to show here.
libs/base/base.ipkg+51−32
This diff is too big to show here.
libs/contrib/CFFI.idrnew file+4
This diff is too big to show here.
libs/contrib/CFFI/Memory.idrnew file+99
This diff is too big to show here.
libs/contrib/CFFI/Types.idrnew file+161
This diff is too big to show here.
libs/contrib/Control/Algebra.idrnew file+147
This diff is too big to show here.
libs/contrib/Control/Algebra/Lattice.idrnew file+140
This diff is too big to show here.
libs/contrib/Control/Algebra/Laws.idrnew file+153
This diff is too big to show here.
libs/contrib/Control/Algebra/NumericImplementations.idrnew file+134
This diff is too big to show here.
libs/contrib/Control/Algebra/VectorSpace.idrnew file+32
This diff is too big to show here.
libs/contrib/Control/Delayed.idrnew file+26
This diff is too big to show here.
libs/contrib/Control/Isomorphism/Extra.idrnew file+42
This diff is too big to show here.
libs/contrib/Control/Isomorphism/Fin.idrnew file+54
This diff is too big to show here.
libs/base/Control/Isomorphism/Primitives.idr → libs/contrib/Control/Isomorphism/Primitives.idrrenamed+5−5
This diff is too big to show here.
libs/contrib/Control/Isomorphism/Vect.idrnew file+155
This diff is too big to show here.
libs/contrib/Control/Monad/Syntax.idrnew file+18
This diff is too big to show here.
libs/contrib/Control/Partial.idrnew file+14
This diff is too big to show here.
libs/contrib/Control/Pipeline.idrnew file+26
This diff is too big to show here.
libs/contrib/Control/ST.idrnew file+660
This diff is too big to show here.
libs/contrib/Control/ST/Exception.idrnew file+38
This diff is too big to show here.
libs/contrib/Control/ST/File.idrnew file+247
This diff is too big to show here.
libs/contrib/Control/ST/ImplicitCall.idrnew file+13
This diff is too big to show here.
libs/contrib/Control/ST/Random.idrnew file+42
This diff is too big to show here.
libs/contrib/Data/Bool/Extra.idrnew file+82
This diff is too big to show here.
libs/contrib/Data/BoundedList.idrnew file+125
This diff is too big to show here.
libs/contrib/Data/Chain.idrnew file+46
This diff is too big to show here.
libs/contrib/Data/CoList.idrnew file+54
This diff is too big to show here.
libs/contrib/Data/Combinators.idrnew file+38
This diff is too big to show here.
libs/contrib/Data/Combinators/Applicative.idrnew file+27
This diff is too big to show here.
libs/contrib/Data/Combinators/Arrow.idrnew file+15
This diff is too big to show here.
libs/contrib/Data/Fin/Extra.idrnew file+86
This diff is too big to show here.
libs/contrib/Data/Fuel.idrnew file+18
This diff is too big to show here.
libs/contrib/Data/Fun.idrnew file+18
This diff is too big to show here.
libs/contrib/Data/Graph.idrnew file+8
This diff is too big to show here.
libs/contrib/Data/Hash.idrnew file+87
This diff is too big to show here.
libs/base/Data/Heap.idr → libs/contrib/Data/Heap.idrrenamed+31−47
This diff is too big to show here.
libs/contrib/Data/IOArray.idrnew file+47
This diff is too big to show here.
libs/contrib/Data/List/Group.idrnew file+27
This diff is too big to show here.
libs/contrib/Data/List/Permutations.idrnew file+12
This diff is too big to show here.
libs/contrib/Data/List/Reverse.idrnew file+99
This diff is too big to show here.
libs/contrib/Data/List/Zipper.idrnew file+160
This diff is too big to show here.
libs/contrib/Data/Logic/Propositional.idrnew file+161
This diff is too big to show here.
libs/contrib/Data/Matrix.idrnew file+59
This diff is too big to show here.
libs/contrib/Data/Matrix/Algebraic.idrnew file+149
This diff is too big to show here.
libs/contrib/Data/Matrix/Numeric.idrnew file+135
This diff is too big to show here.
libs/contrib/Data/Monoid.idrnew file+33
This diff is too big to show here.
libs/contrib/Data/Nat.idrnew file+25
This diff is too big to show here.
libs/contrib/Data/Nat/Ack.idrnew file+60
This diff is too big to show here.
libs/contrib/Data/Nat/DivMod.idrnew file+61
This diff is too big to show here.
libs/contrib/Data/Nat/DivMod/IteratedSubtraction.idrnew file+165
This diff is too big to show here.
libs/contrib/Data/Nat/Fact.idrnew file+56
This diff is too big to show here.
libs/contrib/Data/Nat/Fib.idrnew file+50
This diff is too big to show here.
libs/contrib/Data/Nat/Parity.idrnew file+217
This diff is too big to show here.
libs/contrib/Data/Pairs/Implicit.idrnew file+13
This diff is too big to show here.
libs/contrib/Data/Polyhedra.idrnew file+9
This diff is too big to show here.
libs/contrib/Data/PosNat.idrnew file+57
This diff is too big to show here.
libs/base/Data/Rel.idr → libs/contrib/Data/Rel.idrrenamed+3−3
This diff is too big to show here.
libs/contrib/Data/Sign.idrnew file+39
This diff is too big to show here.
libs/contrib/Data/SortedBag.idrnew file+127
This diff is too big to show here.
libs/base/Data/SortedMap.idr → libs/contrib/Data/SortedMap.idrrenamed+136−60
This diff is too big to show here.
libs/contrib/Data/SortedSet.idrnew file+66
This diff is too big to show here.
libs/contrib/Data/Storable.idrnew file+41
This diff is too big to show here.
libs/contrib/Data/Stream/Extra.idrnew file+10
This diff is too big to show here.
libs/contrib/Data/String/Extra.idrnew file+88
This diff is too big to show here.
libs/contrib/Data/ZZ.idrnew file+355
This diff is too big to show here.
libs/base/Decidable/Decidable.idr → libs/contrib/Decidable/Decidable.idrrenamed+8−7
This diff is too big to show here.
libs/contrib/Decidable/Order.idrnew file+156
This diff is too big to show here.
libs/contrib/Interfaces/Correlative.idrnew file+63
This diff is too big to show here.
libs/contrib/Interfaces/Proposition.idrnew file+32
This diff is too big to show here.
libs/contrib/Interfaces/Verified.idrnew file+359
This diff is too big to show here.
libs/contrib/Language/JSON.idrnew file+14
This diff is too big to show here.
libs/contrib/Language/JSON/Data.idrnew file+98
This diff is too big to show here.
libs/contrib/Language/JSON/Lexer.idrnew file+40
This diff is too big to show here.
libs/contrib/Language/JSON/Parser.idrnew file+71
This diff is too big to show here.
libs/contrib/Language/JSON/String.idrnew file+16
This diff is too big to show here.
libs/contrib/Language/JSON/String/Lexer.idrnew file+38
This diff is too big to show here.
libs/contrib/Language/JSON/String/Parser.idrnew file+25
This diff is too big to show here.
libs/contrib/Language/JSON/String/Tokens.idrnew file+60
This diff is too big to show here.
libs/contrib/Language/JSON/Tokens.idrnew file+72
This diff is too big to show here.
libs/contrib/Makefilenew file+25
This diff is too big to show here.
libs/base/Network/Cgi.idr → libs/contrib/Network/Cgi.idrrenamed+42−39
This diff is too big to show here.
libs/contrib/Network/Socket.idrnew file+246
This diff is too big to show here.
libs/contrib/Network/Socket/Data.idrnew file+172
This diff is too big to show here.
libs/contrib/Network/Socket/Raw.idrnew file+199
This diff is too big to show here.
libs/contrib/System/Concurrency/Process.idrnew file+86
This diff is too big to show here.
libs/contrib/Test/Unit.idrnew file+14
This diff is too big to show here.
libs/contrib/Test/Unit/Assertions.idrnew file+37
This diff is too big to show here.
libs/contrib/Test/Unit/Display.idrnew file+27
This diff is too big to show here.
libs/contrib/Test/Unit/Generic.idrnew file+43
This diff is too big to show here.
libs/contrib/Test/Unit/Runners.idrnew file+36
This diff is too big to show here.
libs/contrib/Text/Lexer.idrnew file+324
This diff is too big to show here.
libs/contrib/Text/Lexer/Core.idrnew file+193
This diff is too big to show here.
libs/contrib/Text/Literate.idrnew file+155
This diff is too big to show here.
libs/contrib/Text/Parser.idrnew file+226
This diff is too big to show here.
libs/contrib/Text/Parser/Core.idrnew file+265
This diff is too big to show here.
libs/contrib/Text/PrettyPrint/WL.idrnew file+18
This diff is too big to show here.
libs/contrib/Text/PrettyPrint/WL/Characters.idrnew file+103
This diff is too big to show here.
libs/contrib/Text/PrettyPrint/WL/Combinators.idrnew file+259
This diff is too big to show here.
libs/contrib/Text/PrettyPrint/WL/Core.idrnew file+226
This diff is too big to show here.
libs/contrib/Text/Quantity.idrnew file+38
This diff is too big to show here.
libs/contrib/Text/Token.idrnew file+38
This diff is too big to show here.
libs/contrib/contrib.ipkgnew file+113
This diff is too big to show here.
libs/effects/Effect/Default.idrnew file+47
This diff is too big to show here.
libs/effects/Effect/Exception.idr+16−24
This diff is too big to show here.
libs/effects/Effect/File.idr+408−49
This diff is too big to show here.
libs/effects/Effect/Logging/Category.idrnew file+181
This diff is too big to show here.
libs/effects/Effect/Logging/Default.idrnew file+118
This diff is too big to show here.
libs/effects/Effect/Logging/Level.idrnew file+81
This diff is too big to show here.
libs/effects/Effect/Memory.idr+75−61
This diff is too big to show here.
libs/effects/Effect/Monad.idr+21−12
This diff is too big to show here.
libs/effects/Effect/Perf.idrnew file+230
This diff is too big to show here.
libs/effects/Effect/Random.idr+55−14
This diff is too big to show here.
libs/effects/Effect/Select.idr+9−7
This diff is too big to show here.
libs/effects/Effect/State.idr+16−16
This diff is too big to show here.
libs/effects/Effect/StdIO.idr+53−40
This diff is too big to show here.
libs/effects/Effect/System.idrnew file+52
This diff is too big to show here.
libs/effects/Effect/Trans.idrnew file+20
This diff is too big to show here.
libs/effects/Effects.idr+421−261
This diff is too big to show here.
libs/effects/Makefile+13−5
This diff is too big to show here.
libs/effects/effects.ipkg+20−5
This diff is too big to show here.
libs/javascript/JavaScript.idrdeleted−104
This diff is too big to show here.
libs/javascript/JavaScript/JSON.idrdeleted−46
This diff is too big to show here.
libs/javascript/Makefiledeleted−14
This diff is too big to show here.
libs/javascript/javascript.ipkgdeleted−5
This diff is too big to show here.
libs/neweffects/Effect/Default.idrdeleted−44
This diff is too big to show here.
libs/neweffects/Effect/Exception.idrdeleted−39
This diff is too big to show here.
libs/neweffects/Effect/File.idrdeleted−62
This diff is too big to show here.
libs/neweffects/Effect/Memory.idrdeleted−175
This diff is too big to show here.
libs/neweffects/Effect/Monad.idrdeleted−21
This diff is too big to show here.
libs/neweffects/Effect/Random.idrdeleted−25
This diff is too big to show here.
libs/neweffects/Effect/Select.idrdeleted−23
This diff is too big to show here.
libs/neweffects/Effect/State.idrdeleted−40
This diff is too big to show here.
libs/neweffects/Effect/StdIO.idrdeleted−37
This diff is too big to show here.
libs/neweffects/Effects.idrdeleted−291
This diff is too big to show here.
libs/neweffects/Makefiledeleted−14
This diff is too big to show here.
libs/neweffects/neweffects.ipkgdeleted−9
This diff is too big to show here.
libs/prelude/Builtins.idr+218−52
This diff is too big to show here.
libs/prelude/Decidable/Equality.idr+127−112
This diff is too big to show here.
libs/prelude/IO.idr+351−126
This diff is too big to show here.
libs/prelude/Language/Reflection.idrnew file+1287
This diff is too big to show here.
libs/prelude/Language/Reflection/Elab.idrnew file+775
This diff is too big to show here.
libs/base/Language/Reflection/Errors.idr → libs/prelude/Language/Reflection/Errors.idrrenamed+14−15
This diff is too big to show here.
libs/prelude/Makefile+14−6
This diff is too big to show here.
libs/prelude/Prelude.idr+208−462
This diff is too big to show here.
libs/prelude/Prelude/Algebra.idr+21−247
This diff is too big to show here.
libs/prelude/Prelude/Applicative.idr+56−16
This diff is too big to show here.
libs/prelude/Prelude/Basics.idr+32−18
This diff is too big to show here.
libs/prelude/Prelude/Bits.idr+106−50
This diff is too big to show here.
libs/prelude/Prelude/Bool.idr+29−16
This diff is too big to show here.
libs/prelude/Prelude/Cast.idr+28−18
This diff is too big to show here.
libs/prelude/Prelude/Chars.idr+40−21
This diff is too big to show here.
libs/prelude/Prelude/Doubles.idrnew file+64
This diff is too big to show here.
libs/prelude/Prelude/Either.idr+47−16
This diff is too big to show here.
libs/prelude/Prelude/File.idrnew file+391
This diff is too big to show here.
libs/prelude/Prelude/Fin.idrdeleted−84
This diff is too big to show here.
libs/prelude/Prelude/Foldable.idr+50−13
This diff is too big to show here.
libs/prelude/Prelude/Functor.idr+29−2
This diff is too big to show here.
libs/prelude/Prelude/Interactive.idrnew file+180
This diff is too big to show here.
libs/prelude/Prelude/Classes.idr → libs/prelude/Prelude/Interfaces.idrrenamed+204−110
This diff is too big to show here.
libs/prelude/Prelude/List.idr+563−193
This diff is too big to show here.
libs/prelude/Prelude/Maybe.idr+72−22
This diff is too big to show here.
libs/prelude/Prelude/Monad.idr+42−11
This diff is too big to show here.
libs/prelude/Prelude/Nat.idr+454−526
This diff is too big to show here.
libs/prelude/Prelude/Pairs.idrnew file+45
This diff is too big to show here.
libs/prelude/Prelude/Providers.idrnew file+33
This diff is too big to show here.
libs/prelude/Prelude/Show.idrnew file+196
This diff is too big to show here.
libs/prelude/Prelude/Stream.idr+78−12
This diff is too big to show here.
libs/prelude/Prelude/Strings.idr+301−48
This diff is too big to show here.
libs/prelude/Prelude/Traversable.idr+23−3
This diff is too big to show here.
libs/prelude/Prelude/Uninhabited.idr+19−10
This diff is too big to show here.
libs/prelude/Prelude/Vect.idrdeleted−368
This diff is too big to show here.
libs/prelude/Prelude/WellFounded.idrnew file+135
This diff is too big to show here.
libs/prelude/prelude.ipkg+37−9
This diff is too big to show here.
libs/pruviloj/Makefilenew file+22
This diff is too big to show here.
libs/pruviloj/Pruviloj.idrnew file+8
This diff is too big to show here.
libs/pruviloj/Pruviloj/Core.idrnew file+331
This diff is too big to show here.
libs/pruviloj/Pruviloj/Derive/DecEq.idrnew file+196
This diff is too big to show here.
libs/pruviloj/Pruviloj/Derive/Eliminators.idrnew file+265
This diff is too big to show here.
libs/pruviloj/Pruviloj/Disjoint.idrnew file+125
This diff is too big to show here.
libs/pruviloj/Pruviloj/Induction.idrnew file+159
This diff is too big to show here.
libs/pruviloj/Pruviloj/Injective.idrnew file+122
This diff is too big to show here.
libs/pruviloj/Pruviloj/Internals.idrnew file+136
This diff is too big to show here.
libs/pruviloj/Pruviloj/Internals/TyConInfo.idrnew file+108
This diff is too big to show here.
libs/pruviloj/Pruviloj/Renamers.idrnew file+44
This diff is too big to show here.
libs/pruviloj/README.txtnew file+45
This diff is too big to show here.
libs/pruviloj/pruviloj.ipkgnew file+19
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
logos/logo-text.svgnew file+150
This diff is too big to show here.
logos/logo.svgnew file+80
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
papers/impl-paper/Makefiledeleted−43
This diff is too big to show here.
papers/impl-paper/acmtrans.bstdeleted−1770
This diff is too big to show here.
papers/impl-paper/acmtrans2m.clsdeleted−1460
This diff is too big to show here.
papers/impl-paper/comments.stydeleted−29
This diff is too big to show here.
papers/impl-paper/compiling.texdeleted−2
This diff is too big to show here.
papers/impl-paper/conclusions.texdeleted−167
This diff is too big to show here.
papers/impl-paper/delab.texdeleted−159
This diff is too big to show here.
papers/impl-paper/elaboration.texdeleted−1956
This diff is too big to show here.
papers/impl-paper/hll.texdeleted−441
This diff is too big to show here.
papers/impl-paper/impldtp.texdeleted−159
This diff is too big to show here.
papers/impl-paper/intro.texdeleted−196
This diff is too big to show here.
papers/impl-paper/jfp.bstdeleted−1316
This diff is too big to show here.
papers/impl-paper/jfp1.clsdeleted−1894
This diff is too big to show here.
papers/impl-paper/library.bibdeleted−2295
This diff is too big to show here.
papers/impl-paper/library.ltxdeleted−325
This diff is too big to show here.
papers/impl-paper/literature.bibdeleted−3846
This diff is too big to show here.
papers/impl-paper/macros.ltxdeleted−1066
This diff is too big to show here.
papers/impl-paper/overview.texdeleted−35
This diff is too big to show here.
papers/impl-paper/proofstate.texdeleted−7
This diff is too big to show here.
papers/impl-paper/syntax.texdeleted−10
This diff is too big to show here.
papers/impl-paper/typechecking.texdeleted−718
This diff is too big to show here.
This diff is too big to show here.
rts/arduino/idris_main.cnew file+29
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
rts/idris_bitstring.c+284−387
This diff is too big to show here.
rts/idris_bitstring.h+10−5
This diff is too big to show here.
rts/idris_buffer.cnew file+146
This diff is too big to show here.
rts/idris_buffer.hnew file+29
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
rts/idris_stdfgn.c+266−13
This diff is too big to show here.
This diff is too big to show here.
rts/idris_utf8.cnew file+180
This diff is too big to show here.
rts/idris_utf8.hnew file+26
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
rts/seL4/CMakeLists.txtnew file+43
This diff is too big to show here.
rts/seL4/README.mdnew file+5
This diff is too big to show here.
rts/seL4/idris_main.cnew file+31
This diff is too big to show here.
rts/windows/win_utils.cnew file+67
This diff is too big to show here.
rts/windows/win_utils.hnew file+9
This diff is too big to show here.
samples/ST/Composite.idrnew file+8
This diff is too big to show here.
samples/ST/Graphics/Draw.idrnew file+88
This diff is too big to show here.
samples/ST/Graphics/Turtle.idrnew file+116
This diff is too big to show here.
samples/ST/Intro.idrnew file+75
This diff is too big to show here.
samples/ST/Login.idrnew file+55
This diff is too big to show here.
samples/ST/LoginCount.idrnew file+77
This diff is too big to show here.
samples/ST/Net/EchoSimple.idrnew file+24
This diff is too big to show here.
samples/ST/Net/Network.idrnew file+106
This diff is too big to show here.
samples/ST/Net/RandServer.idrnew file+156
This diff is too big to show here.
samples/ST/Net/Threads.idrnew file+23
This diff is too big to show here.
samples/ST/TreeTag.idrnew file+29
This diff is too big to show here.
samples/effects/ConsoleIO.idrnew file+15
This diff is too big to show here.
samples/effects/Exception.idrnew file+21
This diff is too big to show here.
samples/effects/Makefilenew file+8
This diff is too big to show here.
samples/effects/Random.idrnew file+37
This diff is too big to show here.
samples/effects/ReadInt.idrnew file+22
This diff is too big to show here.
samples/effects/Select.idrnew file+17
This diff is too big to show here.
samples/effects/TreeTag-noeff.idrnew file+21
This diff is too big to show here.
samples/effects/TreeTag.idrnew file+40
This diff is too big to show here.
samples/effects/TreeTagCount.idrnew file+29
This diff is too big to show here.
samples/effects/hworld.idrnew file+10
This diff is too big to show here.
samples/effects/vadd.idrnew file+41
This diff is too big to show here.
examples/Makefile → samples/misc/Makefilerenamed+1−1
This diff is too big to show here.
samples/binary.idr → samples/misc/binary.idrrenamed+3−4
This diff is too big to show here.
samples/interp-alt.idr → samples/misc/interp-alt.idrrenamed+15−15
This diff is too big to show here.
samples/interp.idr → samples/misc/interp.idrrenamed+26−18
This diff is too big to show here.
samples/javaffi.idr → samples/misc/javaffi.idrrenamed+1−1
This diff is too big to show here.
samples/named_instance.lidr → samples/misc/named_implementation.lidrrenamed+5−5
This diff is too big to show here.
samples/reflection.idr → samples/misc/reflection.idrrenamed+27−27
This diff is too big to show here.
examples/bmain.idr → samples/tutorial/BMain.idrrenamed+2−2
This diff is too big to show here.
examples/btree.idr → samples/tutorial/BTree.idrrenamed+4
This diff is too big to show here.
samples/tutorial/BTreeMod.idrnew file+20
This diff is too big to show here.
examples/foo.idr → samples/tutorial/Foo.idrrenamed
The content is the same.
examples/hello.idr → samples/tutorial/Hello.idrrenamed
The content is the same.
samples/tutorial/Idiom.idrnew file+38
This diff is too big to show here.
examples/classes.idr → samples/tutorial/Interfaces.idrrenamed+1−1
This diff is too big to show here.
examples/interp.idr → samples/tutorial/Interp.idrrenamed+18−18
This diff is too big to show here.
examples/letbind.idr → samples/tutorial/LetBind.idrrenamed+1−1
This diff is too big to show here.
samples/tutorial/Makefilenew file+11
This diff is too big to show here.
examples/prims.idr → samples/tutorial/Prims.idrrenamed+1−1
This diff is too big to show here.
samples/tutorial/Record.idrnew file+21
This diff is too big to show here.
samples/tutorial/Theorems.idrnew file+37
This diff is too big to show here.
examples/universe.idr → samples/tutorial/Universe.idrrenamed
The content is the same.
examples/usefultypes.idr → samples/tutorial/UsefulTypes.idrrenamed+1
This diff is too big to show here.
samples/tutorial/VBroken.idrnew file+10
This diff is too big to show here.
samples/tutorial/Views.idrnew file+25
This diff is too big to show here.
samples/tutorial/ViewsBroken.idrnew file+12
This diff is too big to show here.
samples/tutorial/Wheres.idrnew file+14
This diff is too big to show here.
scripts/generate-multi-ghc-travis-templatenew file+20
This diff is too big to show here.
scripts/runidrisnew file+25
This diff is too big to show here.
scripts/runidris-nodenew file+25
This diff is too big to show here.
src/IRTS/BCImp.hsdeleted−19
This diff is too big to show here.
src/IRTS/Bytecode.hs+103−40
This diff is too big to show here.
src/IRTS/CodegenC.hs+602−166
This diff is too big to show here.
src/IRTS/CodegenCommon.hs+38−7
This diff is too big to show here.
src/IRTS/CodegenJava.hsdeleted−754
This diff is too big to show here.
src/IRTS/CodegenJavaScript.hs+69−1850
This diff is too big to show here.
src/IRTS/CodegenLLVM.hsdeleted−1316
This diff is too big to show here.
src/IRTS/Compiler.hs+748−380
This diff is too big to show here.
src/IRTS/Defunctionalise.hs+108−115
This diff is too big to show here.
This diff is too big to show here.
src/IRTS/Exports.hsnew file+114
This diff is too big to show here.
This diff is too big to show here.
src/IRTS/Java/ASTBuilding.hsdeleted−141
This diff is too big to show here.
src/IRTS/Java/JTypes.hsdeleted−300
This diff is too big to show here.
src/IRTS/Java/Mangling.hsdeleted−116
This diff is too big to show here.
src/IRTS/Java/Pom.hsdeleted−89
This diff is too big to show here.
src/IRTS/JavaScript/AST.hsnew file+285
This diff is too big to show here.
src/IRTS/JavaScript/Codegen.hsnew file+636
This diff is too big to show here.
src/IRTS/JavaScript/LangTransforms.hsnew file+99
This diff is too big to show here.
src/IRTS/JavaScript/Name.hsnew file+57
This diff is too big to show here.
src/IRTS/JavaScript/PrimOp.hsnew file+246
This diff is too big to show here.
src/IRTS/JavaScript/Specialize.hsnew file+109
This diff is too big to show here.
This diff is too big to show here.
src/IRTS/LangOpts.hsnew file+327
This diff is too big to show here.
src/IRTS/Portable.hsnew file+363
This diff is too big to show here.
src/IRTS/Simplified.hs+102−98
This diff is too big to show here.
This diff is too big to show here.
src/Idris/ASTUtils.hsnew file+166
This diff is too big to show here.
src/Idris/AbsSyntax.hs+1570−836
This diff is too big to show here.
src/Idris/AbsSyntaxTree.hs+2042−1105
This diff is too big to show here.
src/Idris/Apropos.hsnew file+106
This diff is too big to show here.
src/Idris/CaseSplit.hs+253−155
This diff is too big to show here.
src/Idris/Chaser.hs+202−93
This diff is too big to show here.
src/Idris/CmdOptions.hsnew file+305
This diff is too big to show here.
src/Idris/Colours.hs+66−22
This diff is too big to show here.
src/Idris/Completion.hs+118−90
This diff is too big to show here.
src/Idris/Core/Binary.hsnew file+368
This diff is too big to show here.
src/Idris/Core/CaseTree.hs+538−345
This diff is too big to show here.
src/Idris/Core/Constraints.hs+247−59
This diff is too big to show here.
src/Idris/Core/DeepSeq.hs+56−105
This diff is too big to show here.
src/Idris/Core/Elaborate.hs+482−207
This diff is too big to show here.
src/Idris/Core/Evaluate.hs+633−302
This diff is too big to show here.
src/Idris/Core/Execute.hs+481−321
This diff is too big to show here.
src/Idris/Core/ProofState.hs+601−417
This diff is too big to show here.
src/Idris/Core/ProofTerm.hsnew file+363
This diff is too big to show here.
src/Idris/Core/TC.hsdeleted−28
This diff is too big to show here.
src/Idris/Core/TT.hs+1023−327
This diff is too big to show here.
src/Idris/Core/Typecheck.hs+311−148
This diff is too big to show here.
src/Idris/Core/Unify.hs+501−365
This diff is too big to show here.
src/Idris/Core/WHNF.hsnew file+256
This diff is too big to show here.
src/Idris/Coverage.hs+460−719
This diff is too big to show here.
This diff is too big to show here.
src/Idris/DataOpts.hs+39−251
This diff is too big to show here.
src/Idris/DeepSeq.hs+92−282
This diff is too big to show here.
src/Idris/Delaborate.hs+625−141
This diff is too big to show here.
src/Idris/Directives.hsnew file+130
This diff is too big to show here.
This diff is too big to show here.
src/Idris/Docstrings.hsnew file+301
This diff is too big to show here.
src/Idris/Elab/AsPat.hsnew file+73
This diff is too big to show here.
src/Idris/Elab/Clause.hsnew file+1251
This diff is too big to show here.
src/Idris/Elab/Data.hsnew file+313
This diff is too big to show here.
src/Idris/Elab/Implementation.hsnew file+489
This diff is too big to show here.
src/Idris/Elab/Interface.hsnew file+449
This diff is too big to show here.
src/Idris/Elab/Provider.hsnew file+99
This diff is too big to show here.
src/Idris/Elab/Quasiquote.hsnew file+180
This diff is too big to show here.
src/Idris/Elab/Record.hsnew file+446
This diff is too big to show here.
src/Idris/Elab/Rewrite.hsnew file+259
This diff is too big to show here.
src/Idris/Elab/RunElab.hsnew file+53
This diff is too big to show here.
src/Idris/Elab/Term.hsnew file+2788
This diff is too big to show here.
src/Idris/Elab/Transform.hsnew file+100
This diff is too big to show here.
src/Idris/Elab/Type.hsnew file+257
This diff is too big to show here.
src/Idris/Elab/Utils.hsnew file+824
This diff is too big to show here.
src/Idris/Elab/Value.hsnew file+124
This diff is too big to show here.
src/Idris/ElabDecls.hs+186−2098
This diff is too big to show here.
src/Idris/ElabTerm.hsdeleted−1664
This diff is too big to show here.
src/Idris/Erasure.hsnew file+634
This diff is too big to show here.
src/Idris/ErrReverse.hs+29−28
This diff is too big to show here.
src/Idris/Error.hs+119−30
This diff is too big to show here.
This diff is too big to show here.
src/Idris/IBC.hs+942−1919
This diff is too big to show here.
src/Idris/IdeMode.hsnew file+342
This diff is too big to show here.
src/Idris/IdeSlave.hsdeleted−176
This diff is too big to show here.
src/Idris/IdrisDoc.hsnew file+702
This diff is too big to show here.
src/Idris/Imports.hs+109−20
This diff is too big to show here.
src/Idris/Info.hsnew file+94
This diff is too big to show here.
src/Idris/Info/Show.hsnew file+143
This diff is too big to show here.
src/Idris/Inliner.hs+13−8
This diff is too big to show here.
src/Idris/Interactive.hsnew file+504
This diff is too big to show here.
src/Idris/Main.hsnew file+309
This diff is too big to show here.
src/Idris/ModeCommon.hsnew file+187
This diff is too big to show here.
src/Idris/Options.hsnew file+291
This diff is too big to show here.
src/Idris/Output.hsnew file+531
This diff is too big to show here.
src/Idris/Package.hsnew file+524
This diff is too big to show here.
src/Idris/Package/Common.hsnew file+41
This diff is too big to show here.
src/Idris/Package/Parser.hsnew file+148
This diff is too big to show here.
src/Idris/ParseData.hsdeleted−235
This diff is too big to show here.
src/Idris/ParseExpr.hsdeleted−1190
This diff is too big to show here.
src/Idris/ParseHelpers.hsdeleted−519
This diff is too big to show here.
src/Idris/ParseOps.hsdeleted−152
This diff is too big to show here.
src/Idris/Parser.hs+1226−659
This diff is too big to show here.
src/Idris/Parser/Data.hsnew file+304
This diff is too big to show here.
src/Idris/Parser/Expr.hsnew file+1580
This diff is too big to show here.
src/Idris/Parser/Helpers.hsnew file+559
This diff is too big to show here.
src/Idris/Parser/Ops.hsnew file+249
This diff is too big to show here.
src/Idris/Parser/Stack.hsnew file+161
This diff is too big to show here.
src/Idris/PartialEval.hs+321−76
This diff is too big to show here.
src/Idris/Primitives.hs+56−258
This diff is too big to show here.
src/Idris/ProofSearch.hs+467−61
This diff is too big to show here.
src/Idris/Prover.hs+471−132
This diff is too big to show here.
src/Idris/Providers.hs+31−15
This diff is too big to show here.
src/Idris/REPL.hs+1265−1080
This diff is too big to show here.
src/Idris/REPL/Browse.hsnew file+52
This diff is too big to show here.
src/Idris/REPL/Commands.hsnew file+81
This diff is too big to show here.
src/Idris/REPL/Parser.hsnew file+540
This diff is too big to show here.
src/Idris/REPLParser.hsdeleted−171
This diff is too big to show here.
src/Idris/Reflection.hsnew file+1230
This diff is too big to show here.
src/Idris/Termination.hsnew file+639
This diff is too big to show here.
src/Idris/Transforms.hs+95−43
This diff is too big to show here.
src/Idris/TypeSearch.hsnew file+564
This diff is too big to show here.
This diff is too big to show here.
src/Idris/UnusedArgs.hsdeleted−65
This diff is too big to show here.
src/Idris/WhoCalls.hsnew file+98
This diff is too big to show here.
src/Pkg/PParser.hsdeleted−81
This diff is too big to show here.
src/Pkg/Package.hsdeleted−206
This diff is too big to show here.
src/Util/DynamicLinker.hs+103−28
This diff is too big to show here.
src/Util/LLVMStubs.hsdeleted−31
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
src/Util/ScreenSize.hs+9−17
This diff is too big to show here.
src/Util/System.hs+126−20
This diff is too big to show here.
src/Util/Zlib.hsdeleted−15
This diff is too big to show here.
stack-11.22.yamlnew file+21
This diff is too big to show here.
stack-12.26.yamlnew file+20
This diff is too big to show here.
stack-15.3.yamlnew file+17
This diff is too big to show here.
stack-15.4.yamlnew file+17
This diff is too big to show here.
stack-shell.nixnew file+24
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
support/Makefiledeleted−15
This diff is too big to show here.
support/network.cdeleted−260
This diff is too big to show here.
support/network.hdeleted−36
This diff is too big to show here.
support/testidr.cdeleted−6
This diff is too big to show here.
support/testidr.hdeleted−7
This diff is too big to show here.
support/threads.cdeleted−116
This diff is too big to show here.
support/threads.hdeleted−11
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
test/README.mdnew file+160
This diff is too big to show here.
test/TestData.hsnew file+350
This diff is too big to show here.
test/TestRun.hsnew file+128
This diff is too big to show here.
test/base001/Makefilenew file+11
This diff is too big to show here.
test/base001/base001.idrnew file+35
This diff is too big to show here.
test/base001/base001.ipkgnew file+5
This diff is too big to show here.
test/base001/exit1.cnew file+21
This diff is too big to show here.
test/base001/expected.outnew file+25
This diff is too big to show here.
test/base001/run.shnew file+12
This diff is too big to show here.
test/base001/sys.cnew file+15
This diff is too big to show here.
test/base001/sys.hnew file+7
This diff is too big to show here.
test/basic001/basic001a.idrnew file+34
This diff is too big to show here.
test/basic001/expected → test/basic001/expected.outrenamed+1
This diff is too big to show here.
test/basic001/reg005.idr+20−17
This diff is too big to show here.
test/basic001/run.shnew file+6
This diff is too big to show here.
test/basic002/expecteddeleted−1
This diff is too big to show here.
test/basic002/expected.outnew file+13
This diff is too big to show here.
test/basic002/run → test/basic002/run.shrenamed+1−1
This diff is too big to show here.
test/basic002/test006.idr+10−11
This diff is too big to show here.
test/basic003/expected → test/basic003/expected.outrenamed
The content is the same.
test/basic003/run → test/basic003/run.shrenamed+1−1
This diff is too big to show here.
test/basic003/test027.idr+3−3
This diff is too big to show here.
test/basic004/expected → test/basic004/expected.outrenamed
The content is the same.
test/basic004/run → test/basic004/run.shrenamed+1−1
This diff is too big to show here.
test/basic004/test016.idr+1−1
This diff is too big to show here.
test/basic005/expected → test/basic005/expected.outrenamed
The content is the same.
test/basic005/run → test/basic005/run.shrenamed+1−1
This diff is too big to show here.
test/basic005/test019.lidr+8−6
This diff is too big to show here.
test/basic006/expecteddeleted−13
This diff is too big to show here.
test/basic006/expected.outnew file+15
This diff is too big to show here.
test/basic006/rundeleted−5
This diff is too big to show here.
test/basic006/run.shnew file+6
This diff is too big to show here.
test/basic006/test020.idr+4−2
This diff is too big to show here.
test/basic006/test020a.idr+3−1
This diff is too big to show here.
test/basic007/expected → test/basic007/expected.outrenamed
The content is the same.
test/basic007/run → test/basic007/run.shrenamed+1−1
This diff is too big to show here.
test/basic007/test033.idr+1−1
This diff is too big to show here.
test/basic008/expected → test/basic008/expected.outrenamed
The content is the same.
test/basic008/run → test/basic008/run.shrenamed+1−1
This diff is too big to show here.
test/basic008/test036.idr+2−2
This diff is too big to show here.
This diff is too big to show here.
This diff is too big to show here.
test/basic009/Faulty.idr+1−1
This diff is too big to show here.
test/basic009/Main.idr+4−4
This diff is too big to show here.
test/basic009/Multiple.idr+2−2
This diff is too big to show here.
test/basic009/expecteddeleted−4
This diff is too big to show here.
test/basic009/expected.outnew file+32
This diff is too big to show here.
test/basic009/rundeleted−5
This diff is too big to show here.
test/basic009/run.shnew file+8
This diff is too big to show here.
test/basic010/Main.idrnew file+43
This diff is too big to show here.
test/basic010/expected.outnew file+3
This diff is too big to show here.
test/basic010/run.shnew file+10
This diff is too big to show here.
test/basic011/basic011.idrnew file+20
This diff is too big to show here.
test/basic011/expected.outnew file+14
This diff is too big to show here.
test/basic011/run.shnew file+4
This diff is too big to show here.
test/basic012/basic012.idrnew file+63
This diff is too big to show here.
test/basic012/basic012a.idrnew file+10
This diff is too big to show here.
test/basic012/expected.outnew file+2
This diff is too big to show here.
test/basic012/run.shnew file+5
This diff is too big to show here.
test/basic013/basic013.idrnew file+78
This diff is too big to show here.
test/basic013/expected.outnew file+59
This diff is too big to show here.
test/basic013/run.shnew file+4
This diff is too big to show here.
test/basic014/basic014.idrnew file+44
This diff is too big to show here.
test/error002/expected → test/basic014/expected.outrenamed
The content is the same.
test/basic014/run.shnew file+3
This diff is too big to show here.
test/basic015/basic015.idrnew file+73
This diff is too big to show here.
test/basic015/expected.outnew file+3
This diff is too big to show here.
test/basic015/run.shnew file+4
This diff is too big to show here.
test/basic016/CycleA.idrnew file+4
This diff is too big to show here.
test/basic016/CycleB.idrnew file+5
This diff is too big to show here.
test/basic016/CycleC.idrnew file+4
This diff is too big to show here.
test/basic016/expected.outnew file+1
This diff is too big to show here.
test/basic016/run.shnew file+3
This diff is too big to show here.
test/basic017/basic017.idrnew file+25
This diff is too big to show here.
test/basic017/basic017a.idrnew file+15
This diff is too big to show here.
test/basic017/expected.outnew file+8
This diff is too big to show here.
test/basic017/run.shnew file+4
This diff is too big to show here.
test/basic018/basic018.idrnew file+14
This diff is too big to show here.
test/basic018/expected.outnew file+32
This diff is too big to show here.
test/basic018/run.shnew file+3
This diff is too big to show here.
test/basic019/basic019.idrnew file+10
This diff is too big to show here.
test/basic019/expected.outnew file+12
This diff is too big to show here.
test/basic019/run.shnew file+4
This diff is too big to show here.
test/basic020/basic020.idrnew file+42
This diff is too big to show here.
test/basic020/expected.outnew file+1
This diff is too big to show here.
test/basic020/run.shnew file+4
This diff is too big to show here.
test/basic021/basic021.idrnew file+13
This diff is too big to show here.
test/basic021/basic021_2.idrnew file+13
This diff is too big to show here.
test/basic021/expected.outnew file+2
This diff is too big to show here.
test/basic021/run.shnew file+6
This diff is too big to show here.
test/basic022/basic022.idrnew file+13
This diff is too big to show here.
test/basic022/expected.outnew file+1
This diff is too big to show here.
test/basic022/run.shnew file+4
This diff is too big to show here.
test/basic023/expected.outnew file+10
This diff is too big to show here.
test/basic023/run.shnew file+4
This diff is too big to show here.
test/basic023/sections.idrnew file+34
This diff is too big to show here.
test/basic024/basic024.idrnew file+51
This diff is too big to show here.
test/basic024/expected.outnew file+76
This diff is too big to show here.
test/basic024/input.innew file+46
This diff is too big to show here.
test/basic024/run.shnew file+8
This diff is too big to show here.
test/basic025/basic025.idrnew file+28
This diff is too big to show here.
test/basic025/expected.outnew file+12
This diff is too big to show here.
test/basic025/input.innew file+7
This diff is too big to show here.
test/basic025/run.shnew file+7
This diff is too big to show here.
test/basic026/basic026.idrnew file+12
This diff is too big to show here.
test/basic026/expected.outnew file+2
This diff is too big to show here.
test/basic026/run.shnew file+4
This diff is too big to show here.
test/bignum001/bignum001.idrnew file+17
This diff is too big to show here.
test/bignum001/expected.outnew file+1
This diff is too big to show here.
test/bignum001/run.shnew file+4
This diff is too big to show here.
test/bignum002/bignum002.idrnew file+14
This diff is too big to show here.
test/bignum002/expected.outnew file+8
This diff is too big to show here.
test/bignum002/run.shnew file+4
This diff is too big to show here.
test/bignum003/bignum003.idrnew file+23
This diff is too big to show here.
test/bignum003/expected.outnew file+2
This diff is too big to show here.
test/bignum003/run.shnew file+4
This diff is too big to show here.
test/bounded001/bounded001.idrnew file+10
This diff is too big to show here.
test/bounded001/expected.outnew file+6
This diff is too big to show here.
test/bounded001/run.shnew file+4
This diff is too big to show here.
test/buffer001-disabled/buffer001.idrdeleted−45
This diff is too big to show here.
test/buffer001-disabled/expecteddeleted−3
This diff is too big to show here.
test/buffer001-disabled/rundeleted−4
This diff is too big to show here.
test/buffer001/buffer001.idrnew file+33
This diff is too big to show here.
test/buffer001/expected.outnew file+7
This diff is too big to show here.
test/buffer001/run.shnew file+4
This diff is too big to show here.
test/buffer002/buffer002.idrnew file+34
This diff is too big to show here.
test/buffer002/expected.outnew file+11
This diff is too big to show here.
test/buffer002/run.shnew file+4
This diff is too big to show here.
test/contrib001/contrib001.idrnew file+14
This diff is too big to show here.
test/contrib001/expected.outnew file+12
This diff is too big to show here.
test/contrib001/run.shnew file+4
This diff is too big to show here.
test/corecords001/corecords001.idrnew file+24
This diff is too big to show here.
test/corecords001/expected.outnew file+5
This diff is too big to show here.
test/corecords001/run.shnew file+4
This diff is too big to show here.
test/corecords002/corecords002.idrnew file+24
This diff is too big to show here.
test/corecords002/expected.outnew file+3
This diff is too big to show here.
test/corecords002/run.shnew file+4
This diff is too big to show here.
test/delab001/delab001.idrnew file+16
This diff is too big to show here.
test/delab001/expected.outnew file+12
This diff is too big to show here.
test/delab001/input.innew file+4
This diff is too big to show here.
test/delab001/run.shnew file+3
This diff is too big to show here.
test/directives001/directives001.idrnew file+28
This diff is too big to show here.
test/directives001/expected.outnew file+42
This diff is too big to show here.
test/directives001/run.shnew file+4
This diff is too big to show here.
test/directives002/directives002.idrnew file+14
This diff is too big to show here.
test/directives002/expected.outnew file+6
This diff is too big to show here.
test/directives002/run.shnew file+4
This diff is too big to show here.
test/directives003/directives003.idrnew file+11
This diff is too big to show here.
test/directives003/expected.outnew file+6
This diff is too big to show here.
test/directives003/run.shnew file+13
This diff is too big to show here.
test/disambig002/disambig002.idrnew file+84
This diff is too big to show here.
test/ffi004/expected → test/disambig002/expected.outrenamed
The content is the same.
test/disambig002/run.shnew file+3
This diff is too big to show here.
test/docs001/docs001.idrnew file+20
This diff is too big to show here.
test/docs001/expected.outnew file+17
This diff is too big to show here.
test/docs001/input.innew file+1
This diff is too big to show here.
test/docs001/run.shnew file+3
This diff is too big to show here.
test/docs002/docs002.idrnew file+17
This diff is too big to show here.
test/docs002/expected.outnew file+12
This diff is too big to show here.
test/docs002/input.innew file+3
This diff is too big to show here.
test/docs002/run.shnew file+3
This diff is too big to show here.
test/docs003/docs003.idrnew file+9
This diff is too big to show here.
test/docs003/expected.outnew file+41
This diff is too big to show here.
test/docs003/input.innew file+3
This diff is too big to show here.
test/docs003/run.shnew file+3
This diff is too big to show here.
test/docs004/docs004.idrnew file+11
This diff is too big to show here.
test/docs004/expected.outnew file+18
This diff is too big to show here.
test/docs004/input.innew file+3
This diff is too big to show here.
test/docs004/run.shnew file+3
This diff is too big to show here.
test/docs005/docs005.idrnew file+19
This diff is too big to show here.
test/docs005/expected.outnew file+31
This diff is too big to show here.
test/docs005/input.innew file+2
This diff is too big to show here.
test/docs005/run.shnew file+3
This diff is too big to show here.
test/docs006/docs006.idrnew file+7
This diff is too big to show here.
test/docs006/expected.outnew file+16
This diff is too big to show here.
test/docs006/input.innew file+1
This diff is too big to show here.
test/docs006/run.shnew file+3
This diff is too big to show here.
test/dsl001/expecteddeleted−2
This diff is too big to show here.
test/dsl001/expected.outnew file+14
This diff is too big to show here.
test/dsl001/input.innew file+2
This diff is too big to show here.
This diff is too big to show here.
test/dsl001/run.shnew file+5
This diff is too big to show here.
test/dsl001/test001.idr+24−16
This diff is too big to show here.
test/dsl002/Resimp.idr+35−24
This diff is too big to show here.
test/dsl002/expected → test/dsl002/expected.outrenamed−1
This diff is too big to show here.
test/dsl002/run → test/dsl002/run.shrenamed+1−1
This diff is too big to show here.
test/dsl002/test → test/dsl002/test.inrenamed
The content is the same.
test/dsl002/test014.idr+12−10
This diff is too big to show here.
test/dsl003/DSLPi.idrnew file+49
This diff is too big to show here.
test/dsl003/expected.outnew file+2
This diff is too big to show here.
test/dsl003/run.shnew file+3
This diff is too big to show here.
test/dsl004/Door0.idrnew file+35
This diff is too big to show here.
test/dsl004/Door1.idrnew file+39
This diff is too big to show here.
test/dsl004/Door2.idrnew file+39
This diff is too big to show here.
test/dsl004/Door3.idrnew file+32
This diff is too big to show here.
test/dsl004/IOu.idrnew file+21
This diff is too big to show here.
test/proof001/expected → test/dsl004/expected.outrenamed
The content is the same.
test/dsl004/run.shnew file+5
This diff is too big to show here.
test/effects001/expected → test/effects001/expected.outrenamed+2−2
This diff is too big to show here.
test/effects001/rundeleted−6
This diff is too big to show here.
test/effects001/run.shnew file+6
This diff is too big to show here.
test/effects001/test021.idr+39−26
This diff is too big to show here.
test/effects001/test021a.idr+6−5
This diff is too big to show here.
test/effects001/testFile → test/effects001/testFile.inrenamed
The content is the same.
test/effects002/expected → test/effects002/expected.outrenamed
The content is the same.
test/effects002/rundeleted−4
This diff is too big to show here.
test/effects002/run.shnew file+4
This diff is too big to show here.
test/effects002/test025.idr+12−11
This diff is too big to show here.
test/effects003/VectMissing.idrnew file+12
This diff is too big to show here.
test/effects003/expected.outnew file+31
This diff is too big to show here.
test/effects003/hangman.idrnew file+229
This diff is too big to show here.
test/effects003/input.innew file+6
This diff is too big to show here.
test/effects003/run.shnew file+4
This diff is too big to show here.
test/effects004/effects004.idrnew file+19
This diff is too big to show here.
test/effects004/expected.outnew file+11
This diff is too big to show here.
test/effects004/input.innew file+10
This diff is too big to show here.
test/effects004/run.shnew file+4
This diff is too big to show here.
test/effects005/categoryLogger.idrnew file+23
This diff is too big to show here.
test/effects005/defaultLogger.idrnew file+14
This diff is too big to show here.
test/effects005/expected.outnew file+5
This diff is too big to show here.
test/effects005/run.shnew file+6
This diff is too big to show here.
test/error001/expecteddeleted−1
This diff is too big to show here.
test/error001/expected.outnew file+13
This diff is too big to show here.
test/error001/rundeleted−3
This diff is too big to show here.
test/error001/run.shnew file+3
This diff is too big to show here.
test/proof004/expected → test/error002/expected.outrenamed
The content is the same.
test/error002/run → test/error002/run.shrenamed+1−1
This diff is too big to show here.
test/error002/test031.idr+1−1
This diff is too big to show here.
test/error003/ErrorReflection.idr+5−15
This diff is too big to show here.
test/error003/expecteddeleted−3
This diff is too big to show here.
test/error003/expected.outnew file+9
This diff is too big to show here.
test/error003/rundeleted−3
This diff is too big to show here.
test/error003/run.shnew file+3
This diff is too big to show here.
test/error004/FunErrTest.idr+13−12
This diff is too big to show here.
test/error004/expecteddeleted−4
This diff is too big to show here.
test/error004/expected.outnew file+20
This diff is too big to show here.
test/error004/rundeleted−3
This diff is too big to show here.
test/error004/run.shnew file+3
This diff is too big to show here.
test/error005/error005.idrnew file+27
This diff is too big to show here.
test/error005/expected.outnew file+56
This diff is too big to show here.
test/error005/run.shnew file+3
This diff is too big to show here.
test/error006/WithPatsNoWith.idrnew file+17
This diff is too big to show here.
test/error006/expected.outnew file+21
This diff is too big to show here.
test/error006/run.shnew file+3
This diff is too big to show here.
test/error007/error007.idrnew file+29
This diff is too big to show here.
test/error007/expected.outnew file+19
This diff is too big to show here.
test/error007/run.shnew file+3
This diff is too big to show here.
test/error008/error008.idrnew file+5
This diff is too big to show here.
test/error008/error008a.idrnew file+5
This diff is too big to show here.
test/error008/expected.outnew file+14
This diff is too big to show here.
test/error008/run.shnew file+4
This diff is too big to show here.
test/error009/expected.outnew file+1
This diff is too big to show here.
test/error009/run.shnew file+2
This diff is too big to show here.
test/ffi001/expecteddeleted−2
This diff is too big to show here.
test/ffi001/expected.outnew file+1
This diff is too big to show here.
This diff is too big to show here.
test/ffi001/run.shnew file+3
This diff is too big to show here.
test/ffi001/test022.idr+2−2
This diff is too big to show here.
test/ffi002/expecteddeleted−1
This diff is too big to show here.
test/ffi002/expected.outnew file+6
This diff is too big to show here.
This diff is too big to show here.
test/ffi002/run.shnew file+3
This diff is too big to show here.
test/ffi002/test023.idr+4−6
This diff is too big to show here.
test/ffi003/expecteddeleted−2
This diff is too big to show here.
test/ffi003/expected.outnew file+1
This diff is too big to show here.
test/ffi003/input → test/ffi003/input.inrenamed
The content is the same.
This diff is too big to show here.
test/ffi003/run.shnew file+3
This diff is too big to show here.
test/reg001/expected → test/ffi004/expected.outrenamed
The content is the same.
This diff is too big to show here.
test/ffi004/run.shnew file+3
This diff is too big to show here.
test/ffi004/test026.idr+3−5
This diff is too big to show here.
test/ffi004/theOtherType+1−1
This diff is too big to show here.
test/ffi005/Postulate.idrnew file+12
This diff is too big to show here.
test/ffi005/expected.outnew file+1
This diff is too big to show here.
test/ffi005/run.shnew file+5
This diff is too big to show here.
test/ffi006/expected.outnew file+2
This diff is too big to show here.
test/ffi006/ffi006.cnew file+14
This diff is too big to show here.
test/ffi006/ffi006.idrnew file+30
This diff is too big to show here.
test/ffi006/run.shnew file+5
This diff is too big to show here.
test/ffi007/expected.outnew file+10
This diff is too big to show here.
test/ffi007/ffi007.cnew file+34
This diff is too big to show here.
test/ffi007/ffi007.hnew file+15
This diff is too big to show here.
test/ffi007/ffi007.idrnew file+63
This diff is too big to show here.
test/ffi007/run.shnew file+4
This diff is too big to show here.
test/ffi008/expected.outnew file+5
This diff is too big to show here.
test/ffi008/ffi008.cnew file+25
This diff is too big to show here.
test/ffi008/ffi008.hnew file+19
This diff is too big to show here.
test/ffi008/ffi008.idrnew file+58
This diff is too big to show here.
test/ffi008/run.shnew file+4
This diff is too big to show here.
test/ffi009/Bad.idrnew file+36
This diff is too big to show here.
test/ffi009/Good.idrnew file+37
This diff is too big to show here.
test/ffi009/expected.outnew file+1
This diff is too big to show here.
test/ffi009/ffi009.cnew file+44
This diff is too big to show here.
test/ffi009/ffi009.hnew file+20
This diff is too big to show here.
test/ffi009/run.shnew file+5
This diff is too big to show here.
test/ffi010/expected.outnew file+3
This diff is too big to show here.
test/ffi010/ffi010.idrnew file+43
This diff is too big to show here.
test/ffi010/run.shnew file+4
This diff is too big to show here.
test/ffi011/expected.outnew file+2
This diff is too big to show here.
test/ffi011/ffi011.idrnew file+27
This diff is too big to show here.
test/ffi011/ffi011.jsnew file+7
This diff is too big to show here.
test/ffi011/run.shnew file+4
This diff is too big to show here.
test/ffi012/expected.outnew file+1
This diff is too big to show here.
test/ffi012/ffi012.idrnew file+14
This diff is too big to show here.
test/ffi012/ffi012.jsnew file+3
This diff is too big to show here.
test/ffi012/run.shnew file+4
This diff is too big to show here.
test/ffi013/expected.outnew file+4
This diff is too big to show here.
test/ffi013/ffi013.idrnew file+5
This diff is too big to show here.
test/ffi013/run.shnew file+17
This diff is too big to show here.
test/folding001/expected.outnew file+4
This diff is too big to show here.
test/folding001/folding001.idrnew file+25
This diff is too big to show here.
test/folding001/run.shnew file+4
This diff is too big to show here.
test/idrisdoc001/TestEmpty.idrnew file+1
This diff is too big to show here.
test/idrisdoc001/TestPrivate.idrnew file+5
This diff is too big to show here.
test/idrisdoc001/expected.outnew file+3
This diff is too big to show here.
test/idrisdoc001/run.shnew file+4
This diff is too big to show here.
test/idrisdoc001/test_empty.ipkgnew file+6
This diff is too big to show here.
test/idrisdoc002/TestFunctions.idrnew file+6
This diff is too big to show here.
test/idrisdoc002/expected.outnew file+1
This diff is too big to show here.
test/idrisdoc002/run.shnew file+5
This diff is too big to show here.
test/idrisdoc002/test_functions.ipkgnew file+6
This diff is too big to show here.
test/idrisdoc003/TestDatatypes.idrnew file+7
This diff is too big to show here.
test/idrisdoc003/expected.outnew file+1
This diff is too big to show here.
test/idrisdoc003/run.shnew file+5
This diff is too big to show here.
test/idrisdoc003/test_datatypes.ipkgnew file+6
This diff is too big to show here.
test/idrisdoc004/TestInterfaces.idrnew file+9
This diff is too big to show here.
test/idrisdoc004/expected.outnew file+1
This diff is too big to show here.
test/idrisdoc004/run.shnew file+5
This diff is too big to show here.
test/idrisdoc004/test_interfaces.ipkgnew file+6
This diff is too big to show here.
test/idrisdoc005/TestTracing.idrnew file+5
This diff is too big to show here.
test/idrisdoc005/expected.outnew file+2
This diff is too big to show here.
test/idrisdoc005/run.shnew file+6
This diff is too big to show here.
test/idrisdoc005/test_tracing.ipkgnew file+6
This diff is too big to show here.
test/idrisdoc006/A/fully/Qualified/NAME.idrnew file+6
This diff is too big to show here.
test/idrisdoc006/B.idrnew file+6
This diff is too big to show here.
test/idrisdoc006/expected.outnew file+5
This diff is too big to show here.
test/idrisdoc006/package_a.ipkgnew file+6
This diff is too big to show here.
test/idrisdoc006/package_b.ipkgnew file+6
This diff is too big to show here.
test/idrisdoc006/run.shnew file+17
This diff is too big to show here.
test/idrisdoc007/A.idrnew file+6
This diff is too big to show here.
test/idrisdoc007/expected.outnew file+1
This diff is too big to show here.
test/idrisdoc007/package.ipkgnew file+6
This diff is too big to show here.
test/idrisdoc007/run.shnew file+6
This diff is too big to show here.
test/idrisdoc008/Abstract.idrnew file+5
This diff is too big to show here.
test/idrisdoc008/Visible.idrnew file+5
This diff is too big to show here.
test/idrisdoc008/expected.outnew file+2
This diff is too big to show here.
test/idrisdoc008/run.shnew file+6
This diff is too big to show here.
test/idrisdoc008/visibility.ipkgnew file+6
This diff is too big to show here.
test/idrisdoc009/Test.idrnew file+47
This diff is too big to show here.
test/idrisdoc009/expected.outnew file+30
This diff is too big to show here.
test/idrisdoc009/input.innew file+2
This diff is too big to show here.
test/idrisdoc009/run.shnew file+3
This diff is too big to show here.
test/interactive001/expecteddeleted−14
This diff is too big to show here.
test/interactive001/expected.outnew file+20
This diff is too big to show here.
test/interactive001/inputdeleted−6
This diff is too big to show here.
test/interactive001/input.innew file+8
This diff is too big to show here.
test/interactive001/test032.idr → test/interactive001/interactive001.idrrenamed+10
This diff is too big to show here.
test/interactive001/rundeleted−3
This diff is too big to show here.
test/interactive001/run.shnew file+5
This diff is too big to show here.
test/interactive002/expected → test/interactive002/expected.outrenamed+1−2
This diff is too big to show here.
test/interactive002/inputdeleted−11
This diff is too big to show here.
test/interactive002/input.innew file+11
This diff is too big to show here.
test/interactive002/interactive002.idr+1
This diff is too big to show here.
test/interactive002/rundeleted−3
This diff is too big to show here.
test/interactive002/run.shnew file+3
This diff is too big to show here.
test/interactive003/expected.outnew file+5
This diff is too big to show here.
test/interactive003/input.innew file+5
This diff is too big to show here.
test/interactive003/interactive003.idrnew file+15
This diff is too big to show here.
test/interactive003/run.shnew file+3
This diff is too big to show here.
test/interactive004/expected.outnew file+2
This diff is too big to show here.
test/interactive004/input.innew file+2
This diff is too big to show here.
test/interactive004/interactive004.idrnew file+9
This diff is too big to show here.
test/interactive004/run.shnew file+3
This diff is too big to show here.
test/interactive005/expected.outnew file+36
This diff is too big to show here.
test/interactive005/input.innew file+26
This diff is too big to show here.
test/interactive005/interactive005.idrnew file+3
This diff is too big to show here.
test/interactive005/run.shnew file+6
This diff is too big to show here.
test/interactive006/expected.outnew file+1
This diff is too big to show here.
test/interactive006/input.innew file+1
This diff is too big to show here.
test/interactive006/interactive006.idrnew file+3
This diff is too big to show here.
test/interactive006/run.shnew file+3
This diff is too big to show here.
test/interactive007/expected.outnew file+1
This diff is too big to show here.
test/interactive007/input.innew file+4
This diff is too big to show here.
test/interactive007/run.shnew file+2
This diff is too big to show here.
test/interactive008/expected.outnew file+204
This diff is too big to show here.
test/interactive008/input.innew file+9
This diff is too big to show here.
test/interactive008/run.shnew file+2
This diff is too big to show here.
test/interactive009/expected.outnew file+1
This diff is too big to show here.
test/interactive009/input.innew file+1
This diff is too big to show here.
test/interactive009/interactive009.idrnew file+27
This diff is too big to show here.
test/interactive009/run.shnew file+3
This diff is too big to show here.
test/interactive010/expected.outnew file+24
This diff is too big to show here.
test/interactive010/input.innew file+9
This diff is too big to show here.
test/interactive010/run.shnew file+2
This diff is too big to show here.
test/interactive011/.gitignorenew file+1
This diff is too big to show here.
test/interactive011/expected.outnew file+3
This diff is too big to show here.
test/interactive011/input.innew file+2
This diff is too big to show here.
test/interactive011/interactive011.ipkgnew file+8
This diff is too big to show here.
test/interactive011/run.shnew file+6
This diff is too big to show here.
test/interactive011/src/Foo.idrnew file+5
This diff is too big to show here.
test/interactive011/src/Main.idrnew file+14
This diff is too big to show here.
test/interactive012/expected.outnew file+33
This diff is too big to show here.
test/interactive012/input.innew file+9
This diff is too big to show here.
test/interactive012/interactive012.idrnew file+26
This diff is too big to show here.
test/interactive012/run.shnew file+3
This diff is too big to show here.
test/interactive013/expected.outnew file+4
This diff is too big to show here.
test/interactive013/input.innew file+1
This diff is too big to show here.
test/interactive013/interactive013.idrnew file+4
This diff is too big to show here.
test/interactive013/run.shnew file+3
This diff is too big to show here.
test/interactive014/expected.outnew file+7
This diff is too big to show here.
test/interactive014/input.innew file+5
This diff is too big to show here.
test/interactive014/interactive014.idrnew file+10
This diff is too big to show here.
test/interactive014/run.shnew file+3
This diff is too big to show here.
test/interactive015/expected.outnew file+6
This diff is too big to show here.
test/interactive015/input.innew file+2
This diff is too big to show here.
test/interactive015/run.shnew file+8
This diff is too big to show here.
test/interactive015/src/interactive015.idrnew file+4
This diff is too big to show here.
test/interactive016/expected.outnew file+7
This diff is too big to show here.
test/interactive016/input.innew file+2
This diff is too big to show here.
test/interactive016/run.shnew file+8
This diff is too big to show here.
test/interactive016/src/interactive016.idrnew file+7
This diff is too big to show here.
test/interactive017/TestMod.idrnew file+5
This diff is too big to show here.
test/interactive017/expected.outnew file+7
This diff is too big to show here.
test/interactive017/run.shnew file+9
This diff is too big to show here.
test/interactive017/shebang-args.idrnew file+6
This diff is too big to show here.
test/interactive017/shebang-import.idrnew file+6
This diff is too big to show here.
test/interactive017/shebang-node.idrnew file+4
This diff is too big to show here.
test/interactive017/shebang.idrnew file+4
This diff is too big to show here.
test/interactive018/Imported1.idrnew file+10
This diff is too big to show here.
test/interactive018/Imported2.idrnew file+8
This diff is too big to show here.
test/interactive018/Public1.idrnew file+10
This diff is too big to show here.
test/interactive018/Public2.idrnew file+8
This diff is too big to show here.
test/interactive018/Top.idrnew file+11
This diff is too big to show here.
test/interactive018/expected.outnew file+20
This diff is too big to show here.
test/interactive018/input.innew file+20
This diff is too big to show here.
test/interactive018/run.shnew file+3
This diff is too big to show here.
test/interfaces001/InterfaceName.idrnew file+49
This diff is too big to show here.
test/interfaces001/expected.outnew file+30
This diff is too big to show here.
test/interfaces001/input.innew file+2
This diff is too big to show here.
test/interfaces001/run.shnew file+3
This diff is too big to show here.
test/interfaces002/expected.outnew file+1
This diff is too big to show here.
test/interfaces002/interfaces002.idrnew file+38
This diff is too big to show here.
test/interfaces002/run.shnew file+4
This diff is too big to show here.
test/interfaces003/expected.outnew file+2
This diff is too big to show here.
test/interfaces003/interfaces003.idrnew file+22
This diff is too big to show here.
test/interfaces003/run.shnew file+4
This diff is too big to show here.
test/interfaces004/expected.outnew file+4
This diff is too big to show here.
test/interfaces004/interfaces004.idrnew file+35
This diff is too big to show here.
test/interfaces004/run.shnew file+4
This diff is too big to show here.
test/interfaces005/expected.outnew file+7
This diff is too big to show here.
test/interfaces005/interfaces005.idrnew file+53
This diff is too big to show here.
test/interfaces005/interfaces005a.idrnew file+50
This diff is too big to show here.
test/interfaces005/interfaces005b.idrnew file+50
This diff is too big to show here.
test/interfaces005/run.shnew file+5
This diff is too big to show here.
test/reg005/expected → test/interfaces006/expected.outrenamed
The content is the same.
test/interfaces006/interfaces006.idrnew file+19
This diff is too big to show here.
test/interfaces006/run.shnew file+3
This diff is too big to show here.
test/interfaces007/expected.outnew file+1
This diff is too big to show here.
test/interfaces007/interfaces007.idrnew file+52
This diff is too big to show here.
test/interfaces007/run.shnew file+4
This diff is too big to show here.
test/interfaces008/expected.outnew file+6
This diff is too big to show here.
test/interfaces008/interfaces008.idrnew file+20
This diff is too big to show here.
test/interfaces008/run.shnew file+3
This diff is too big to show here.
test/reg008/expected → test/interfaces009/expected.outrenamed
The content is the same.
test/interfaces009/interfaces009.idrnew file+24
This diff is too big to show here.
test/interfaces009/run.shnew file+3
This diff is too big to show here.
test/reg009/expected → test/interfaces010/expected.outrenamed
The content is the same.
test/interfaces010/interfaces010.idrnew file+12
This diff is too big to show here.
test/interfaces010/run.shnew file+3
This diff is too big to show here.
test/interpret001/double-echo.idrnew file+6
This diff is too big to show here.
test/interpret001/expected.outnew file+2
This diff is too big to show here.
test/interpret001/input.innew file+2
This diff is too big to show here.
test/interpret001/run.shnew file+3
This diff is too big to show here.
test/interpret002/expected.outnew file+4
This diff is too big to show here.
test/interpret002/file-error.idrnew file+6
This diff is too big to show here.
test/interpret002/input.innew file+2
This diff is too big to show here.
test/interpret002/readable.txtnew file+1
This diff is too big to show here.
test/interpret002/run.shnew file+3
This diff is too big to show here.
test/interpret003/expected.outnew file+1
This diff is too big to show here.
test/interpret003/input.innew file+1
This diff is too big to show here.
test/interpret003/interpret003.idrnew file+4
This diff is too big to show here.
test/interpret003/run.shnew file+3
This diff is too big to show here.
test/interpret003/testnew file
Binary file not shown.
test/io001/expected → test/io001/expected.outrenamed
The content is the same.
test/io001/run → test/io001/run.shrenamed+1−1
This diff is too big to show here.
test/io001/test004.idr+8−8
This diff is too big to show here.
test/io002/expected → test/io002/expected.outrenamed
The content is the same.
test/io002/run → test/io002/run.shrenamed+1−1
This diff is too big to show here.
test/io002/test008.idr+2−2
This diff is too big to show here.
test/io003/expected → test/io003/expected.outrenamed
The content is the same.
This diff is too big to show here.
test/io003/run.shnew file+6
This diff is too big to show here.
test/io003/test018.idr+5−2
This diff is too big to show here.
test/io003/test018a.idr+11−8
This diff is too big to show here.
test/layout001/expected.outnew file+82
This diff is too big to show here.
test/layout001/layout001a.idrnew file+5
This diff is too big to show here.
test/layout001/layout001b.idrnew file+5
This diff is too big to show here.
test/layout001/layout001c.idrnew file+3
This diff is too big to show here.
test/layout001/layout001d.idrnew file+3
This diff is too big to show here.
test/layout001/layout001e.idrnew file+6
This diff is too big to show here.
test/layout001/layout001f.idrnew file+6
This diff is too big to show here.
test/layout001/layout001g.idrnew file+6
This diff is too big to show here.
test/layout001/layout001h.idrnew file+6
This diff is too big to show here.
test/layout001/layout001i.idrnew file+6
This diff is too big to show here.
test/layout001/layout001j.idrnew file+6
This diff is too big to show here.
test/layout001/layout001k.idrnew file+6
This diff is too big to show here.
test/layout001/layout001l.idrnew file+6
This diff is too big to show here.
test/layout001/layout001n.idrnew file+33
This diff is too big to show here.
test/layout001/mplus1.idrnew file+17
This diff is too big to show here.
test/layout001/mplus2.idrnew file+17
This diff is too big to show here.
test/layout001/mplus3.idrnew file+17
This diff is too big to show here.
test/layout001/run.shnew file+22
This diff is too big to show here.
test/literate001/Lit.lidr+2−2
This diff is too big to show here.
test/literate001/expecteddeleted−7
This diff is too big to show here.
test/literate001/expected.outnew file+12
This diff is too big to show here.
test/literate001/rundeleted−5
This diff is too big to show here.
test/literate001/run.shnew file+5
This diff is too big to show here.
test/meta001/Finite.idrnew file+188
This diff is too big to show here.
test/reg011/expected → test/meta001/expected.outrenamed
The content is the same.
test/meta001/run.shnew file+3
This diff is too big to show here.
test/meta002/AgdaStyleReflection.idrnew file+320
This diff is too big to show here.
test/meta002/DataDef.idrnew file+75
This diff is too big to show here.
test/meta002/Deriving.idrnew file+35
This diff is too big to show here.
test/meta002/Tacs.idrnew file+304
This diff is too big to show here.
test/meta002/expected.outnew file+25
This diff is too big to show here.
test/meta002/run.shnew file+7
This diff is too big to show here.
test/meta003/BadDef.idrnew file+14
This diff is too big to show here.
test/meta003/Catch.idrnew file+17
This diff is too big to show here.
test/meta003/expected.outnew file+12
This diff is too big to show here.
test/meta003/run.shnew file+5
This diff is too big to show here.
test/meta004/expected.outnew file+7
This diff is too big to show here.
test/meta004/meta004.idrnew file+50
This diff is too big to show here.
test/meta004/run.shnew file+3
This diff is too big to show here.
This diff is too big to show here.
test/pkg001/Main.idrnew file+8
This diff is too big to show here.
test/pkg001/expected.outnew file+23
This diff is too big to show here.
test/pkg001/run.shnew file+8
This diff is too big to show here.
test/pkg001/test-pkg.ipkgnew file+17
This diff is too big to show here.
test/pkg002/Main.idrnew file+4
This diff is too big to show here.
test/reg012/expected → test/pkg002/expected.outrenamed
The content is the same.
test/pkg002/run.shnew file+5
This diff is too big to show here.
test/pkg002/test.ipkgnew file+8
This diff is too big to show here.
test/pkg003/Main.idrnew file+4
This diff is too big to show here.
test/reg014/expected → test/pkg003/expected.outrenamed
The content is the same.
test/pkg003/run.shnew file+6
This diff is too big to show here.
test/pkg003/test.ipkgnew file+7
This diff is too big to show here.
test/pkg004/Main.idrnew file+4
This diff is too big to show here.
test/pkg004/expected.outnew file+6
This diff is too big to show here.
test/pkg004/run.shnew file+6
This diff is too big to show here.
test/pkg004/test.ipkgnew file+8
This diff is too big to show here.
test/pkg005/expected.outnew file+1
This diff is too big to show here.
test/pkg005/run.shnew file+3
This diff is too big to show here.
test/pkg005/test.ipkgnew file+3
This diff is too big to show here.
test/pkg006/expected.outnew file+1
This diff is too big to show here.
test/pkg006/run.shnew file+3
This diff is too big to show here.
test/pkg006/test.ipkgnew file+3
This diff is too big to show here.
test/pkg007/expected.outnew file+1
This diff is too big to show here.
test/pkg007/input.innew file+4
This diff is too big to show here.
test/pkg007/run.shnew file+7
This diff is too big to show here.
test/pkg007/toy/Toy.idrnew file+4
This diff is too big to show here.
test/pkg007/toy/Toy/Vehicle.idrnew file+4
This diff is too big to show here.
test/pkg007/toy/Toy/Vehicle/Car.idrnew file+3
This diff is too big to show here.
test/pkg007/toy/toy.ipkgnew file+7
This diff is too big to show here.
test/pkg008/expected.outnew file+13
This diff is too big to show here.
test/pkg008/maths.ipkgnew file+10
This diff is too big to show here.
test/pkg008/run.shnew file+11
This diff is too big to show here.
test/pkg008/src/NumOps.idrnew file+9
This diff is too big to show here.
test/pkg008/src/Test.idrnew file+21
This diff is too big to show here.
test/pkg009/datatype.ipkgnew file+6
This diff is too big to show here.
test/pkg009/expected.outnew file+9
This diff is too big to show here.
test/pkg009/run.shnew file+7
This diff is too big to show here.
test/pkg009/src/Data/Type.idrnew file+3
This diff is too big to show here.
test/pkg010/expected.outnew file+29
This diff is too big to show here.
test/pkg010/run.shnew file+2
This diff is too big to show here.
test/pkg010/wrongopts.ipkgnew file+3
This diff is too big to show here.
test/prelude001/expected.outnew file+10
This diff is too big to show here.
test/prelude001/prelude001.idrnew file+14
This diff is too big to show here.
test/prelude001/run.shnew file+4
This diff is too big to show here.
test/primitives001/expecteddeleted−6
This diff is too big to show here.
test/primitives001/expected.outnew file+27
This diff is too big to show here.
test/primitives001/input.innew file+2
This diff is too big to show here.
test/primitives001/rundeleted−4
This diff is too big to show here.
test/primitives001/run.shnew file+6
This diff is too big to show here.
test/primitives001/substring.idrnew file+58
This diff is too big to show here.
test/primitives001/test005.idr+5−6
This diff is too big to show here.
test/primitives002/expected → test/primitives002/expected.outrenamed+20−18
This diff is too big to show here.
test/primitives002/rundeleted−49
This diff is too big to show here.
test/primitives002/run.shnew file+54
This diff is too big to show here.
test/primitives003/expected → test/primitives003/expected.outrenamed+4−2
This diff is too big to show here.
test/primitives003/rundeleted−5
This diff is too big to show here.
test/primitives003/run.shnew file+5
This diff is too big to show here.
test/primitives003/test038.idr+20−16
This diff is too big to show here.
test/primitives004-disabled/expected.outnew file+4
This diff is too big to show here.
test/primitives004-disabled/primitives004.idrnew file+8
This diff is too big to show here.
test/primitives004-disabled/run.shnew file+4
This diff is too big to show here.
test/primitives005/expected.outnew file+2
This diff is too big to show here.
test/primitives005/primitives005.idrnew file+24
This diff is too big to show here.
test/primitives005/run.shnew file+5
This diff is too big to show here.
test/primitives006/Data/ByteArray.idrnew file+100
This diff is too big to show here.
test/primitives006/Data/Bytes.idrnew file+286
This diff is too big to show here.
test/primitives006/array.cnew file+62
This diff is too big to show here.
test/primitives006/array.hnew file+18
This diff is too big to show here.
test/primitives006/expected.outnew file+9
This diff is too big to show here.
test/primitives006/load-test.idrnew file+48
This diff is too big to show here.
test/primitives006/run.shnew file+6
This diff is too big to show here.
test/proof001/expected.outnew file+12
This diff is too big to show here.
test/proof001/rundeleted−3
This diff is too big to show here.
test/proof001/run.shnew file+3
This diff is too big to show here.
test/proof001/test029.idr+11−8
This diff is too big to show here.
test/proof002/Reflect.idr+61−59
This diff is too big to show here.
test/proof002/expecteddeleted−11
This diff is too big to show here.
test/proof002/expected.outnew file+37
This diff is too big to show here.
test/proof002/rundeleted−4
This diff is too big to show here.
test/proof002/run.shnew file+4
This diff is too big to show here.
test/proof002/test030.idr−1
This diff is too big to show here.
test/proof003/Parity.idr+8−6
This diff is too big to show here.
test/proof003/expecteddeleted−3
This diff is too big to show here.
test/proof003/expected.outnew file+39
This diff is too big to show here.
test/proof003/run → test/proof003/run.shrenamed+1−1
This diff is too big to show here.
test/proof003/test015.idr+38−34
This diff is too big to show here.
test/reg015/expected → test/proof004/expected.outrenamed
The content is the same.
test/proof004/rundeleted−3
This diff is too big to show here.
test/proof004/run.shnew file+3
This diff is too big to show here.
test/proof005/DefaultArgSubstitutionSuccess.idrnew file+44
This diff is too big to show here.
test/reg019/expected → test/proof005/expected.outrenamed
The content is the same.
test/proof005/run.shnew file+3
This diff is too big to show here.
test/proof006/DefaultArgSubstitutionSyntax.idrnew file+49
This diff is too big to show here.
test/reg021/expected → test/proof006/expected.outrenamed
The content is the same.
test/proof006/run.shnew file+3
This diff is too big to show here.
test/proof007/DefaultArgUnknownName.idrnew file+10
This diff is too big to show here.
test/proof007/expected.outnew file+10
This diff is too big to show here.
test/proof007/run.shnew file+3
This diff is too big to show here.
test/proof008/ClaimAndUnfocus.idrnew file+17
This diff is too big to show here.
test/proof008/expected.outnew file+6
This diff is too big to show here.
test/proof008/run.shnew file+3
This diff is too big to show here.
test/proof009/expected.outnew file+26
This diff is too big to show here.
test/proof009/input.innew file+6
This diff is too big to show here.
test/proof009/proof009.idrnew file+9
This diff is too big to show here.
test/proof009/run.shnew file+3
This diff is too big to show here.
test/proof010/expected.outnew file+6
This diff is too big to show here.
test/proof010/proof010.idrnew file+37
This diff is too big to show here.
test/proof010/run.shnew file+4
This diff is too big to show here.
test/proof011/expected.outnew file+28
This diff is too big to show here.
test/proof011/proof011.idrnew file+21
This diff is too big to show here.
test/proof011/proof011a.idrnew file+14
This diff is too big to show here.
test/proof011/run.shnew file+4
This diff is too big to show here.
test/reg022/expected → test/proofsearch001/expected.outrenamed
The content is the same.
test/proofsearch001/proofsearch001.idrnew file+11
This diff is too big to show here.
test/proofsearch001/run.shnew file+3
This diff is too big to show here.
test/proofsearch002/Process.idrnew file+444
This diff is too big to show here.
test/reg026/expected → test/proofsearch002/expected.outrenamed
The content is the same.
test/proofsearch002/proofsearch002.idrnew file+48
This diff is too big to show here.
test/proofsearch002/run.shnew file+3
This diff is too big to show here.
test/reg030/expected → test/proofsearch003/expected.outrenamed
The content is the same.
test/proofsearch003/proofsearch003.idrnew file+34
This diff is too big to show here.
test/proofsearch003/run.shnew file+3
This diff is too big to show here.
test/reg033/expected → test/pruviloj001/expected.outrenamed
The content is the same.
test/pruviloj001/pruviloj001.idrnew file+84
This diff is too big to show here.
test/pruviloj001/run.shnew file+3
This diff is too big to show here.
test/quasiquote001/QuasiquoteBasics.idrnew file+27
This diff is too big to show here.
test/quasiquote001/expected.outnew file+5
This diff is too big to show here.
test/quasiquote001/run.shnew file+4
This diff is too big to show here.
test/quasiquote002/GoalQQuote.idrnew file+31
This diff is too big to show here.
test/quasiquote002/expected.outnew file+1
This diff is too big to show here.
test/quasiquote002/run.shnew file+4
This diff is too big to show here.
test/quasiquote003/NoInfer.idrnew file+11
This diff is too big to show here.
test/quasiquote003/expected.outnew file+9
This diff is too big to show here.
test/quasiquote003/run.shnew file+3
This diff is too big to show here.
test/quasiquote004/Quasiquote004.idrnew file+51
This diff is too big to show here.
test/quasiquote004/expected.outnew file+27
This diff is too big to show here.
test/quasiquote004/run.shnew file+3
This diff is too big to show here.
test/quasiquote005/Quasiquote005.idrnew file+22
This diff is too big to show here.
test/quasiquote005/expected.outnew file
No changes to the content.
test/quasiquote005/run.shnew file+3
This diff is too big to show here.
test/quasiquote006/expected.outnew file+31
This diff is too big to show here.
test/quasiquote006/quasiquote006.idrnew file+21
This diff is too big to show here.
test/quasiquote006/run.shnew file+3
This diff is too big to show here.
test/records001/expected → test/records001/expected.outrenamed
The content is the same.
test/records001/run → test/records001/run.shrenamed+1−1
This diff is too big to show here.
test/records001/test011.idr+16−12
This diff is too big to show here.
test/records002/expected.outnew file+2
This diff is too big to show here.
test/records002/record002.idrnew file+12
This diff is too big to show here.
test/records002/run.shnew file+4
This diff is too big to show here.
test/records003/expected.outnew file+6
This diff is too big to show here.
test/records003/records003.idrnew file+46
This diff is too big to show here.
test/records003/run.shnew file+4
This diff is too big to show here.
test/records004/expected.outnew file+3
This diff is too big to show here.
test/records004/records004.idrnew file+13
This diff is too big to show here.
test/records004/run.shnew file+4
This diff is too big to show here.
test/records005/expected.outnew file+4
This diff is too big to show here.
test/records005/records005.idrnew file+39
This diff is too big to show here.
test/records005/run.shnew file+4
This diff is too big to show here.
test/reg001/Area.idrnew file+12
This diff is too big to show here.
test/reg001/TestEx.idrnew file+31
This diff is too big to show here.
test/reg001/expected.outnew file+3
This diff is too big to show here.
test/reg001/reg001.idrdeleted−8
This diff is too big to show here.
This diff is too big to show here.
test/reg001/run.shnew file+4
This diff is too big to show here.
test/reg002/expected → test/reg002/expected.outrenamed
The content is the same.
test/reg002/reg002.idr → test/reg002/reg012.idrrenamed+9−7
This diff is too big to show here.
This diff is too big to show here.
test/reg002/run.shnew file+4
This diff is too big to show here.
test/reg003/expecteddeleted−2
This diff is too big to show here.
This diff is too big to show here.
test/reg004/expected → test/reg004/expected.outrenamed
The content is the same.
test/reg004/reg004.idr+1−1
This diff is too big to show here.
test/reg004/run → test/reg004/run.shrenamed+1−1
This diff is too big to show here.
test/reg005/expected.outnew file+3
This diff is too big to show here.
test/reg005/reg005.idrnew file+9
This diff is too big to show here.
test/reg005/reg032.idrdeleted−10
This diff is too big to show here.
This diff is too big to show here.
test/basic001/run → test/reg005/run.shrenamed+1−1
This diff is too big to show here.
test/reg006/expecteddeleted−1
This diff is too big to show here.
This diff is too big to show here.
test/reg007/expecteddeleted−12
This diff is too big to show here.
test/reg007/expected.outnew file+14
This diff is too big to show here.
This diff is too big to show here.
test/reg007/run.shnew file+3
This diff is too big to show here.
test/reg008/reg008.idrdeleted−15
This diff is too big to show here.
This diff is too big to show here.
test/reg009/reg009.lidrdeleted−18
This diff is too big to show here.
This diff is too big to show here.
test/reg010/expecteddeleted−11
This diff is too big to show here.
This diff is too big to show here.
test/reg011/reg011.idrdeleted−9
This diff is too big to show here.
This diff is too big to show here.
test/reg012/reg012.lidrdeleted−34
This diff is too big to show here.
This diff is too big to show here.
test/reg013/expected → test/reg013/expected.outrenamed
The content is the same.
test/reg013/reg013.idr+3−3
This diff is too big to show here.
test/reg013/run → test/reg013/run.shrenamed+1−1
This diff is too big to show here.
test/reg014/reg014.idrdeleted−12
This diff is too big to show here.
This diff is too big to show here.
test/reg015/reg015.idrdeleted−3
This diff is too big to show here.
This diff is too big to show here.
test/reg016/expected → test/reg016/expected.outrenamed
The content is the same.
test/reg016/reg016.idr+6−6
This diff is too big to show here.
test/reg016/run → test/reg016/run.shrenamed+1−1
This diff is too big to show here.
test/reg017/expecteddeleted−1
This diff is too big to show here.
test/reg017/expected.outnew file+13
This diff is too big to show here.
test/reg017/reg017.idr+3−3
This diff is too big to show here.
This diff is too big to show here.
test/reg017/run.shnew file+4
This diff is too big to show here.
test/reg018/expecteddeleted−4
This diff is too big to show here.
This diff is too big to show here.
test/reg019/reg019.idrdeleted−7
This diff is too big to show here.
This diff is too big to show here.
test/reg020/expected → test/reg020/expected.outrenamed
The content is the same.
This diff is too big to show here.
test/reg020/run → test/reg020/run.shrenamed+1−1
This diff is too big to show here.
test/reg021/reg021.idrdeleted−22
This diff is too big to show here.
This diff is too big to show here.
test/reg022/reg022.idrdeleted−18
This diff is too big to show here.
This diff is too big to show here.
test/reg023/expecteddeleted−11
This diff is too big to show here.
This diff is too big to show here.
test/reg024/expected → test/reg024/expected.outrenamed
The content is the same.
test/reg024/run → test/reg024/run.shrenamed+1−1
This diff is too big to show here.
test/reg025/expected → test/reg025/expected.outrenamed
The content is the same.
test/reg025/reg025.idr+15−13
This diff is too big to show here.
test/reg025/run → test/reg025/run.shrenamed+1−1
This diff is too big to show here.
test/reg026/reg026.idrdeleted−14
This diff is too big to show here.
This diff is too big to show here.
test/reg027/expecteddeleted−3
This diff is too big to show here.
test/reg027/expected.outnew file+7
This diff is too big to show here.
test/reg027/reg027.idr+3−18
This diff is too big to show here.
test/reg027/reg027a.idr+2−2
This diff is too big to show here.
This diff is too big to show here.
test/reg027/run.shnew file+5
This diff is too big to show here.
test/reg028/expecteddeleted−2
This diff is too big to show here.
This diff is too big to show here.
test/reg029/Reg029Wrapper.javanew file+17
This diff is too big to show here.
test/reg029/expected → test/reg029/expected.outrenamed
The content is the same.
test/reg029/reg029.idr+4−3
This diff is too big to show here.
This diff is too big to show here.
test/reg029/run.shnew file+17
This diff is too big to show here.
test/reg030/reg030.idrdeleted−15
This diff is too big to show here.
This diff is too big to show here.
test/reg031/expected → test/reg031/expected.outrenamed
The content is the same.
test/reg031/reg031.idr+1−1
This diff is too big to show here.
test/reg031/run → test/reg031/run.shrenamed+1−1
This diff is too big to show here.
test/reg032/expected → test/reg032/expected.outrenamed
The content is the same.
test/reg032/run → test/reg032/run.shrenamed+1−1
This diff is too big to show here.
test/reg033/reg033.idrdeleted−10
This diff is too big to show here.
This diff is too big to show here.
test/reg039/expected.outnew file+1
This diff is too big to show here.
test/reg039/reg039.idrnew file+12
This diff is too big to show here.
test/reg039/run.shnew file+8
This diff is too big to show here.
test/reg040/expected.outnew file+1
This diff is too big to show here.
test/reg040/reg040.idrnew file+7
This diff is too big to show here.
test/reg040/run.shnew file+6
This diff is too big to show here.
test/reg041/expected.outnew file+2
This diff is too big to show here.
test/reg041/ott.idrnew file+41
This diff is too big to show here.
test/reg041/run.shnew file+5
This diff is too big to show here.
test/reg041/showu.idrnew file+23
This diff is too big to show here.
test/reg042/expected.outnew file+1
This diff is too big to show here.
test/reg042/reg042.idrnew file+24
This diff is too big to show here.
test/reg042/run.shnew file+4
This diff is too big to show here.
test/reg045/expected.outnew file+1
This diff is too big to show here.
test/reg045/reg045.idrnew file+19
This diff is too big to show here.
test/reg045/run.shnew file+4
This diff is too big to show here.
test/reg048/expected.outnew file
No changes to the content.
test/reg048/reg048.idrnew file+24
This diff is too big to show here.
test/reg048/run.shnew file+4
This diff is too big to show here.
test/reg051-disabled/expected.outnew file
No changes to the content.
test/reg051-disabled/reg051.idrnew file+99
This diff is too big to show here.
test/reg051-disabled/run.shnew file+3
This diff is too big to show here.
test/reg052/expected.outnew file+1
This diff is too big to show here.
test/reg052/reg052.idrnew file+8
This diff is too big to show here.
test/reg052/run.shnew file+4
This diff is too big to show here.
test/reg067/expected.outnew file+1
This diff is too big to show here.
test/reg067/reg067.idrnew file+23
This diff is too big to show here.
test/reg067/run.shnew file+5
This diff is too big to show here.
test/reg075/expected.outnew file+6
This diff is too big to show here.
test/reg075/input.innew file+1
This diff is too big to show here.
test/reg075/reg075.idrnew file+33
This diff is too big to show here.
test/reg075/run.shnew file+3
This diff is too big to show here.
test/reg076/expected.outnew file+1
This diff is too big to show here.
test/reg076/input.innew file
No changes to the content.
test/reg076/reg076.idrnew file+11
This diff is too big to show here.
test/reg076/run.shnew file+4
This diff is too big to show here.
test/reg077/expected.outnew file
No changes to the content.
test/reg077/reg077.idrnew file+17
This diff is too big to show here.
test/reg077/run.shnew file+3
This diff is too big to show here.
test/regression001/coverage001.idrnew file+79
This diff is too big to show here.
test/regression001/eff001.idrnew file+39
This diff is too big to show here.
test/regression001/expected.outnew file
No changes to the content.
test/regression001/reg001.idrnew file+209
This diff is too big to show here.
test/regression001/reg002.idrnew file+8
This diff is too big to show here.
test/regression001/reg003.idrnew file+11
This diff is too big to show here.
test/regression001/reg004.lidrnew file+43
This diff is too big to show here.
test/regression001/reg005.idrnew file+8
This diff is too big to show here.
test/regression001/reg006.idrnew file+14
This diff is too big to show here.
test/regression001/reg007.idrnew file+69
This diff is too big to show here.
test/regression001/reg036.idrnew file+12
This diff is too big to show here.
test/regression001/reg037.idrnew file+9
This diff is too big to show here.
test/regression001/reg038.idrnew file+17
This diff is too big to show here.
test/regression001/reg046.idrnew file+19
This diff is too big to show here.
test/regression001/reg047.idrnew file+18
This diff is too big to show here.
test/regression001/reg047a.idrnew file+24
This diff is too big to show here.
test/regression001/reg053.idrnew file+9
This diff is too big to show here.
test/regression001/reg057.idrnew file+8
This diff is too big to show here.
test/regression001/reg058.idrnew file+14
This diff is too big to show here.
test/regression001/reg058a.idrnew file+19
This diff is too big to show here.
test/regression001/reg059.idrnew file+8
This diff is too big to show here.
test/regression001/reg060.idrnew file+12
This diff is too big to show here.
test/regression001/reg061.idrnew file+9
This diff is too big to show here.
test/regression001/reg062.idrnew file+13
This diff is too big to show here.
test/regression001/reg063.idrnew file+19
This diff is too big to show here.
test/regression001/reg064.idrnew file+8
This diff is too big to show here.
test/regression001/reg065.idrnew file+26
This diff is too big to show here.
test/regression001/reg066.idrnew file+7
This diff is too big to show here.
test/regression001/reg071.idrnew file+19
This diff is too big to show here.
test/regression001/reg073.lidrnew file+24
This diff is too big to show here.
test/regression001/reg074.idrnew file+21
This diff is too big to show here.
test/regression001/run.shnew file+18
This diff is too big to show here.
test/reg007/A.lidr → test/regression002/A.lidrrenamed+1−1
This diff is too big to show here.
test/regression002/Canonicity.idrnew file+13
This diff is too big to show here.
test/regression002/DoubleEquality.idrnew file+5
This diff is too big to show here.
test/regression002/Mod.idrnew file+12
This diff is too big to show here.
test/regression002/Negation.idrnew file+2
This diff is too big to show here.
test/regression002/badbangop.idrnew file+15
This diff is too big to show here.
test/regression002/baddoublebang.idrnew file+7
This diff is too big to show here.
test/regression002/expected.outnew file+368
This diff is too big to show here.
test/regression002/reg001.idrnew file+2
This diff is too big to show here.
test/regression002/reg002.idrnew file+3
This diff is too big to show here.
test/reg003/reg003.idr → test/regression002/reg003.idrrenamed
The content is the same.
test/reg003/reg003a.idr → test/regression002/reg003a.idrrenamed
The content is the same.
test/reg006/reg006.idr → test/regression002/reg006.idrrenamed+6−5
This diff is too big to show here.
test/reg007/reg007.lidr → test/regression002/reg007.lidrrenamed+1−1
This diff is too big to show here.
test/reg010/reg010.idr → test/regression002/reg010.idrrenamed
The content is the same.
test/reg018/reg018a.idr → test/regression002/reg018a.idrrenamed
The content is the same.
test/reg018/reg018b.idr → test/regression002/reg018b.idrrenamed+1−1
This diff is too big to show here.
test/reg018/reg018c.idr → test/regression002/reg018c.idrrenamed+2
This diff is too big to show here.
test/reg018/reg018d.idr → test/regression002/reg018d.idrrenamed+6−3
This diff is too big to show here.
test/reg023/reg023.idr → test/regression002/reg023.idrrenamed
The content is the same.
test/reg028/reg028.idr → test/regression002/reg028.idrrenamed
The content is the same.
test/reg028/reg028a.idr → test/regression002/reg028a.idrrenamed
The content is the same.
test/regression002/reg034.idrnew file+10
This diff is too big to show here.
test/regression002/reg035.idrnew file+15
This diff is too big to show here.
test/regression002/reg035a.lidrnew file+67
This diff is too big to show here.
test/regression002/reg035b.idrnew file+12
This diff is too big to show here.
test/regression002/reg044.idrnew file+6
This diff is too big to show here.
test/regression002/reg049.idrnew file+5
This diff is too big to show here.
test/regression002/reg054.idrnew file+42
This diff is too big to show here.
test/regression002/reg055.idrnew file+26
This diff is too big to show here.
test/regression002/reg055a.idrnew file+15
This diff is too big to show here.
test/regression002/reg056.idrnew file+14
This diff is too big to show here.
test/regression002/reg068.idrnew file+4
This diff is too big to show here.
test/regression002/reg069.idrnew file+5
This diff is too big to show here.
test/regression002/reg070.idrnew file+15
This diff is too big to show here.
test/regression002/reg076.idrnew file+7
This diff is too big to show here.
test/regression002/reg077.idrnew file+2
This diff is too big to show here.
test/regression002/run.shnew file+41
This diff is too big to show here.
test/regression002/working.idrnew file+21
This diff is too big to show here.
test/regression003/expected.outnew file+1
This diff is too big to show here.
test/regression003/regression003.idrnew file+56
This diff is too big to show here.
test/regression003/run.shnew file+4
This diff is too big to show here.
test/runtest.pldeleted−135
This diff is too big to show here.
test/scripts/timeoutnew file+17
This diff is too big to show here.
test/sourceLocation001/SourceLoc.idrnew file+103
This diff is too big to show here.
test/sourceLocation001/expected.outnew file+35
This diff is too big to show here.
test/sourceLocation001/run.shnew file+4
This diff is too big to show here.
test/st001/expected.outnew file+8
This diff is too big to show here.
test/st001/run.shnew file+6
This diff is too big to show here.
test/st001/test001.idrnew file+66
This diff is too big to show here.
test/st001/testFile.innew file+2
This diff is too big to show here.
test/st002/expected.outnew file+8
This diff is too big to show here.
test/st002/run.shnew file+6
This diff is too big to show here.
test/st002/test002.idrnew file+66
This diff is too big to show here.
test/st002/testFile.innew file+2
This diff is too big to show here.
test/st003/expected.outnew file+8
This diff is too big to show here.
test/st003/run.shnew file+6
This diff is too big to show here.
test/st003/test003.idrnew file+25
This diff is too big to show here.
test/st003/testFile.innew file+2
This diff is too big to show here.
test/st004/expected.outnew file+6
This diff is too big to show here.
test/st004/run.shnew file+6
This diff is too big to show here.
test/st004/test004.idrnew file+24
This diff is too big to show here.
test/st005/expected.outnew file+6
This diff is too big to show here.
test/st005/run.shnew file+7
This diff is too big to show here.
test/st005/test005.idrnew file+33
This diff is too big to show here.
test/st006/expected.outnew file+5
This diff is too big to show here.
test/st006/run.shnew file+6
This diff is too big to show here.
test/st006/test006.idrnew file+37
This diff is too big to show here.
test/st007/expected.outnew file+6
This diff is too big to show here.
test/st007/run.shnew file+6
This diff is too big to show here.
test/st007/test007.idrnew file+24
This diff is too big to show here.
test/sugar001/expected → test/sugar001/expected.outrenamed
The content is the same.
test/sugar001/run → test/sugar001/run.shrenamed+1−1
This diff is too big to show here.
test/sugar001/test007.idr+7−7
This diff is too big to show here.
test/sugar002/expected → test/sugar002/expected.outrenamed
The content is the same.
test/sugar002/run → test/sugar002/run.shrenamed+1−1
This diff is too big to show here.
test/sugar003/expected → test/sugar003/expected.outrenamed
The content is the same.
test/sugar003/run → test/sugar003/run.shrenamed+1−1
This diff is too big to show here.
test/sugar003/test013.idr+1−1
This diff is too big to show here.
test/sugar004/expected.outnew file+4
This diff is too big to show here.
test/sugar004/run.shnew file+7
This diff is too big to show here.
test/sugar004/sugar004.idrnew file+47
This diff is too big to show here.
test/sugar005/As.idrnew file+36
This diff is too big to show here.
test/sugar005/expected.outnew file+9
This diff is too big to show here.
test/sugar005/run.shnew file+4
This diff is too big to show here.
test/syntax001/Syntax.idrnew file+8
This diff is too big to show here.
test/syntax001/SyntaxOk.idrnew file+6
This diff is too big to show here.
test/syntax001/SyntaxTest.idrnew file+5
This diff is too big to show here.
test/syntax001/expected.outnew file+26
This diff is too big to show here.
test/syntax001/run.shnew file+4
This diff is too big to show here.
test/syntax002/expected.outnew file+2
This diff is too big to show here.
test/syntax002/run.shnew file+4
This diff is too big to show here.
test/syntax002/syntax002.idrnew file+22
This diff is too big to show here.
test/tactics001/Tactics.idrnew file+43
This diff is too big to show here.
test/tactics001/expected.outnew file
No changes to the content.
test/tactics001/run.shnew file+3
This diff is too big to show here.
test/totality001/expecteddeleted−3
This diff is too big to show here.
test/totality001/expected.outnew file+18
This diff is too big to show here.
test/totality001/rundeleted−6
This diff is too big to show here.
test/totality001/run.shnew file+6
This diff is too big to show here.
test/totality001/test010.idr+2
This diff is too big to show here.
test/totality002/expecteddeleted−2
This diff is too big to show here.
test/totality002/expected.outnew file+18
This diff is too big to show here.
test/totality002/rundeleted−5
This diff is too big to show here.
test/totality002/run.shnew file+5
This diff is too big to show here.
test/totality002/test017.idr+13−11
This diff is too big to show here.
test/totality002/test017a.idr+2
This diff is too big to show here.
test/totality002/test017b.idr+1−1
This diff is too big to show here.
test/totality003/expecteddeleted−1
This diff is too big to show here.
test/totality003/expected.outnew file+6
This diff is too big to show here.
test/totality003/rundeleted−4
This diff is too big to show here.
test/totality003/run.shnew file+4
This diff is too big to show here.
test/totality003/totality003.idr+1−1
This diff is too big to show here.
test/totality003/totality003a.idr+1−1
This diff is too big to show here.
test/totality004/expected.outnew file+13
This diff is too big to show here.
test/totality004/run.shnew file+5
This diff is too big to show here.
test/totality004/totality004.idrnew file+25
This diff is too big to show here.
test/totality004/totality004a.idrnew file+24
This diff is too big to show here.
test/totality005/expected.outnew file+1
This diff is too big to show here.
test/totality005/run.shnew file+5
This diff is too big to show here.
test/totality005/totality005.idrnew file+10
This diff is too big to show here.
test/totality006/expected.outnew file+18
This diff is too big to show here.
test/totality006/run.shnew file+5
This diff is too big to show here.
test/totality006/totality006.idrnew file+13
This diff is too big to show here.
test/totality006/totality006a.idrnew file+12
This diff is too big to show here.
test/totality006/totality006b.idrnew file+14
This diff is too big to show here.
test/totality007/expected.msysnew file+5
This diff is too big to show here.
test/totality007/expected.outnew file+9
This diff is too big to show here.
test/totality007/run.shnew file+3
This diff is too big to show here.
test/totality007/src/Totality.idrnew file+4
This diff is too big to show here.
test/totality007/totality.ipkgnew file+7
This diff is too big to show here.
test/totality008/expected.outnew file+6
This diff is too big to show here.
test/totality008/run.shnew file+3
This diff is too big to show here.
test/totality008/totality008.idrnew file+8
This diff is too big to show here.
test/totality009/TestLambdaImpossible.idrnew file+26
This diff is too big to show here.
test/totality009/TestLambdaPossible.idrnew file+14
This diff is too big to show here.
test/totality009/TestLambdaPossible2.idrnew file+16
This diff is too big to show here.
test/totality009/expected.outnew file+60
This diff is too big to show here.
test/totality009/run.shnew file+6
This diff is too big to show here.
test/totality010/expected.outnew file+12
This diff is too big to show here.
test/totality010/run.shnew file+3
This diff is too big to show here.
test/totality010/totality010.idrnew file+31
This diff is too big to show here.
test/totality011/expected.outnew file+6
This diff is too big to show here.
test/totality011/run.shnew file+3
This diff is too big to show here.
test/totality011/totality011.lidrnew file+31
This diff is too big to show here.
test/totality012/expected.outnew file+12
This diff is too big to show here.
test/totality012/run.shnew file+5
This diff is too big to show here.
test/totality012/totality012.idrnew file+30
This diff is too big to show here.
test/totality012/totality012a.idrnew file+12
This diff is too big to show here.
test/totality012/totality012b.idrnew file+18
This diff is too big to show here.
test/totality013/expected.outnew file+12
This diff is too big to show here.
test/totality013/run.shnew file+4
This diff is too big to show here.
test/totality013/totality013.idrnew file+16
This diff is too big to show here.
test/totality013/totality013a.idrnew file+17
This diff is too big to show here.
test/totality014/expected.outnew file+13
This diff is too big to show here.
test/totality014/run.shnew file+3
This diff is too big to show here.
test/totality014/totality014.idrnew file+7
This diff is too big to show here.
test/totality015/expected.outnew file+18
This diff is too big to show here.
test/totality015/run.shnew file+4
This diff is too big to show here.
test/totality015/totality015.idrnew file+70
This diff is too big to show here.
test/totality015/totality015a.idrnew file+63
This diff is too big to show here.
test/totality016/expected.outnew file+54
This diff is too big to show here.
test/totality016/run.shnew file+3
This diff is too big to show here.
test/totality016/totality016.idrnew file+48
This diff is too big to show here.
test/totality017/expected.outnew file+36
This diff is too big to show here.
test/totality017/run.shnew file+3
This diff is too big to show here.
test/totality017/totality017.idrnew file+49
This diff is too big to show here.
test/totality018/expected.outnew file+6
This diff is too big to show here.
test/totality018/run.shnew file+3
This diff is too big to show here.
test/totality018/totality018.idrnew file+15
This diff is too big to show here.
test/totality019/expected.outnew file+12
This diff is too big to show here.
test/totality019/run.shnew file+4
This diff is too big to show here.
test/totality019/totality019.idrnew file+14
This diff is too big to show here.
test/totality019/totality019a.idrnew file+81
This diff is too big to show here.
test/totality020/expected.outnew file+12
This diff is too big to show here.
test/totality020/run.shnew file+3
This diff is too big to show here.
test/totality020/totality020.idrnew file+11
This diff is too big to show here.
test/totality021/expected.outnew file+30
This diff is too big to show here.
test/totality021/run.shnew file+4
This diff is too big to show here.
test/totality021/totality021.idrnew file+18
This diff is too big to show here.
test/totality021/totality021a.idrnew file+12
This diff is too big to show here.
test/totality022/expected.outnew file+6
This diff is too big to show here.
test/totality022/run.shnew file+3
This diff is too big to show here.
test/totality022/totality022.idrnew file+11
This diff is too big to show here.
test/totality023/expected.outnew file+6
This diff is too big to show here.
test/totality023/run.shnew file+3
This diff is too big to show here.
test/totality023/totality023.idrnew file+11
This diff is too big to show here.
test/totality024/expected.outnew file+1
This diff is too big to show here.
test/totality024/run.shnew file+3
This diff is too big to show here.
test/totality024/totality023.idrnew file+7
This diff is too big to show here.
test/totality025/expected.outnew file+18
This diff is too big to show here.
test/totality025/run.shnew file+3
This diff is too big to show here.
test/totality025/totality025.idrnew file+17
This diff is too big to show here.
test/totality026/expected.outnew file+6
This diff is too big to show here.
test/totality026/run.shnew file+3
This diff is too big to show here.
test/totality026/totality026.idrnew file+7
This diff is too big to show here.
test/tutorial001/expected.outnew file
No changes to the content.
test/tutorial001/run.shnew file+3
This diff is too big to show here.
test/tutorial001/tutorial001.idrnew file+9
This diff is too big to show here.
test/tutorial002/expected.outnew file+18
This diff is too big to show here.
test/tutorial002/run.shnew file+3
This diff is too big to show here.
test/tutorial002/tutorial002.idrnew file+61
This diff is too big to show here.
test/tutorial003/expected.outnew file
No changes to the content.
test/tutorial003/run.shnew file+3
This diff is too big to show here.
examples/idiom.idr → test/tutorial003/tutorial003.idrrenamed+3−3
This diff is too big to show here.
test/tutorial004/expected.outnew file+12
This diff is too big to show here.
test/tutorial004/run.shnew file+3
This diff is too big to show here.
examples/theorems.idr → test/tutorial004/tutorial004.idrrenamed+10−10
This diff is too big to show here.
test/tutorial005/expected.outnew file
No changes to the content.
test/tutorial005/run.shnew file+3
This diff is too big to show here.
examples/wheres.idr → test/tutorial005/tutorial005.idrrenamed
The content is the same.
test/tutorial006/expected.outnew file+37
This diff is too big to show here.
test/tutorial006/run.shnew file+5
This diff is too big to show here.
examples/vbroken.idr → test/tutorial006/tutorial006a.idrrenamed+2
This diff is too big to show here.
test/tutorial006/tutorial006b.idrnew file+12
This diff is too big to show here.
test/tutorial006/tutorial006c.idrnew file+20
This diff is too big to show here.
test/tutorial007/Providers.idrnew file+27
This diff is too big to show here.
test/tutorial007/expected.outnew file+1
This diff is too big to show here.
test/tutorial007/nativetypes.cnew file+13
This diff is too big to show here.
test/tutorial007/run.shnew file+5
This diff is too big to show here.
test/tutorial007/tutorial007.idrnew file+12
This diff is too big to show here.
test/unique001/expected.outnew file+4
This diff is too big to show here.
test/unique001/run.shnew file+6
This diff is too big to show here.
test/unique001/unique001.idrnew file+34
This diff is too big to show here.
test/unique004/expected.outnew file+75
This diff is too big to show here.
test/unique004/run.shnew file+14
This diff is too big to show here.
test/unique004/unique001a.idrnew file+64
This diff is too big to show here.
test/unique004/unique001b.idrnew file+32
This diff is too big to show here.
test/unique004/unique001c.idrnew file+47
This diff is too big to show here.
test/unique004/unique001d.idrnew file+4
This diff is too big to show here.
test/unique004/unique001e.idrnew file+5
This diff is too big to show here.
test/unique004/unique002.idrnew file+22
This diff is too big to show here.
test/unique004/unique002a.idrnew file+20
This diff is too big to show here.
test/unique004/unique003.idrnew file+24
This diff is too big to show here.
test/universes001/expected.outnew file+14
This diff is too big to show here.
test/universes001/run.shnew file+3
This diff is too big to show here.
test/universes001/universes001.idrnew file+8
This diff is too big to show here.
test/universes002/expected.outnew file+14
This diff is too big to show here.
test/universes002/run.shnew file+3
This diff is too big to show here.
test/universes002/universes002.idrnew file+45
This diff is too big to show here.
test/views001/expected.outnew file+5
This diff is too big to show here.
test/views001/run.shnew file+6
This diff is too big to show here.
test/views001/views001.idrnew file+43
This diff is too big to show here.
test/views001/views001a.idrnew file+29
This diff is too big to show here.
test/views002/expected.outnew file+2
This diff is too big to show here.
test/views002/run.shnew file+4
This diff is too big to show here.
test/views002/views002.idrnew file+26
This diff is too big to show here.
test/views003/expected.outnew file+1
This diff is too big to show here.
test/views003/run.shnew file+4
This diff is too big to show here.
test/views003/views003.idrnew file+31
This diff is too big to show here.
This diff is too big to show here.