.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
13−*.swp
10+src/Version_idris.hs
15−.DS_Store
12+# Doc generation artefacts
21libs/base/base_doc/
13libs/base/base_doc/
22libs/effects/effects_doc/
14libs/effects/effects_doc/
23libs/prelude/prelude_doc/
15libs/prelude/prelude_doc/
24libs/contrib/contrib_doc/
16libs/contrib/contrib_doc/
17+libs/pruviloj/pruviloj_doc/
18+libs/oldeffects/oldeffects_doc/
25test/output
21test/output
26test/*[0-9][0-9][0-9]/output
22test/*[0-9][0-9][0-9]/output
27test/*[0-9][0-9][0-9]/*.exe
23test/*[0-9][0-9][0-9]/*.exe
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,42 +1,176 @@
1−language: haskell
3+language: c
3− # Idris won't build on 7.4 and earlier due to dependency
5+env:
4− # problems. 7.10 isn't yet supported on Travis.
6+ global:
5− - 7.6
7+ - PKGNAME=idris
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
8before_install:
54before_install:
9− - sudo add-apt-repository --yes ppa:h-rayflood/llvm
55+ - nvm install 6
10− - sudo apt-get update -qq
56+ - nvm use 6
11− - sudo apt-get install -qq libgc-dev llvm-3.3
57+ - unset CC
12− - 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' ]];
13− # trifecta dependencies
59+ then
14− - sudo apt-get install -qq libghc-blaze-builder-dev libghc-blaze-html-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;
15− # Haddock dependencies
61+ export SED=sed;
16− - sudo apt-get install hscolour
62+ export ZCAT=zcat;
17− # test dependency
63+ fi
18− - sudo apt-get install -qq expect
64+ - env
19− - sudo apt-get install -qq cppcheck
65+ - if [[ $TRAVIS_OS_NAME == 'osx' ]];
20− - cabal install alex-3.1.3
66+ then
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;
22− - cabal install -f FFI --enable-tests --dependencies-only --max-backjumps=-1
92+ - which cabal
23− - ghc-pkg list
93+ - which ghc
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;
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/;
24before_script:
132before_script:
133+ - ORIGINAL_DIR=$(pwd)
25− - cabal sdist
134+ - cabal v1-sdist
27− - tar -xf Idris-dev/dist/idris*.tar.gz
136+ - tar -xf ${ORIGINAL_DIR}/dist/${PKGNAME}*.tar.gz
28− - 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'
30− - cabal configure -f FFI -f CI
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'
31− - if [[ "$TESTS" != "doc" ]]; then cabal build; fi
146+ - cabal v1-build
147+ - echo -en 'travis_fold:end:script.build\\r'
149+ - echo 'Copy...' && echo -en 'travis_fold:start:script.copy\\r'
32− - if [[ "$TESTS" != "doc" ]]; then cabal copy; fi
150+ - cabal v1-copy
151+ - echo -en 'travis_fold:end:script.copy\\r'
153+ - echo 'Register...' && echo -en 'travis_fold:start:script.register\\r'
33− - if [[ "$TESTS" != "doc" ]]; then cabal register; fi
154+ - cabal v1-register
34− - if [[ "$TESTS" == "test_c" ]]; then cppcheck -j 2 --error-exitcode=1 ./rts/idris_bitstring.c ./rts/idris_bitstring.h ./rts/idris_gc.h ./rts/idris_gc.c ./rts/idris_gmp.h ./rts/idris_gmp.c ./rts/idris_heap.h ./rts/idris_heap.c ./rts/idris_main.c ./rts/idris_net.h ./rts/idris_net.c ./rts/idris_opts.h ./rts/idris_opts.c ./rts/idris_rts.h ./rts/idris_rts.c ./rts/idris_stats.h ./rts/idris_stats.c ./rts/idris_stdfgn.h ./rts/idris_stdfgn.c ./rts/libtest.c ; fi
155+ - echo -en 'travis_fold:end:script.register\\r'
35− - if [[ "$TESTS" == "test_llvm" ]]; then git clone --depth 1 https://github.com/idris-hackers/idris-llvm.git ; cd idris-llvm ; cabal install ; cd .. ; fi
156+###
36− - make -j2 $TESTS
157+ - echo 'Cppcheck...' && echo -en 'travis_fold:start:script.cppcheck\\r'
37−env:
158+ - if [[ "$TESTS" == "test_c" ]]; then
38− - TESTS="doc"
159+ cppcheck -i 'mini-gmp.c' rts;
39− - TESTS="lib_doc"
160+ fi
40− - TESTS="test_c"
161+ - echo -en 'travis_fold:end:script.cppcheck\\r'
41− #- TESTS="test_llvm"
162+###
42− - TESTS="test_js"
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,553 +0,0 @@
3−* GHC 7.10 compatibility
4−* Add support for bundled toolchains.
5−* Strings are now UTF8 encoded in the default back end
6−* Idris source files are now assumed to be in UTF8, regardless of locale
8−* Some reorganisation of primitives:
9− + Buffer and BitVector primitives have been removed (they were not
10− tested sufficiently, and lack a maintainer)
11− + Float has been renamed 'Double' (Float is defined in the Prelude for
13− + Externally defined primitives and operations now supported with
14− '%extern' directive, allowing back ends to define their own special
16− + Ptr and ManagedPtr have been removed and replaced with external primitives
17−* Add %hint function annotation, which allows functions to be used as
18− hints in proof search for 'auto' arguments. Only functions which return
19− an instance of a data or record type are allowed as hints.
20−* Syntax rules no longer perform variable capture. Users of effects will
21− need to explicitly name results in dependent effect signatures instead
22− of using the default name "result".
23−* Pattern-matching lambdas are allowed to be impossible. For example,
24− Dec (2 = 3) can now be constructed with No $ \(Refl) impossible, instead of
25− requiring a separate lemma.
26−* Case alternatives are allowed to be impossible:
27− case Vect.Nil {a=Nat} of { (x::xs) impossible ; [] => True }
28−* The default Semigroup and Monoid instances for Maybe are now prioritised
29− choice, keeping the first success as Alternative does. The version that
30− collects successes is now a named instance.
31−* :exec REPL command now takes an optional expression to compile and run/show
32−* The return types of `Vect.findIndex`, `Vect.elemIndex` and
33− `Vect.elemIndexBy` were changed from `Maybe Nat` to `Maybe (Fin n)`
34−* A new :browse command shows the contents of a namespace
35−* `{n} is syntax for a quotation of the reflected representation of the name
36− "n". If "n" is lexically bound, then the resulting quotation will be for it,
37− whereas if it is not, then it will succeed with a quotation of the unique
38− global name that matches.
39−* New syntax for records that closely matches our other record-like structures:
40− type classes. See the updated tutorial for details.
41−* Records can be coinductive. Define coinductive records with the "corecord"
43−* Type class constructors can be assigned user-accessible names. This is done
44− using the same syntax as record constructors.
45−* if ... then ... else ... is now built-in syntax instead of being defined in
46− a library. It is shown in REPL output and error messages, rather than its
48−* The desugaring of if ... then ... else ... has been renamed to ifThenElse from
49− boolElim. This is for consistency with GHC Haskell and scala-virtualized, and
50− to reflect that if-notation makes sense with non-Bool datatypes.
51−* Agda-style semantic highlighting is supported over the IDE protocol.
52−* Experimental support for elaborator reflection. Users can now script the
53− elaborator, for use in code generation and proof automation. This feature is
54− still under rapid development and is subject to change without notice. See
55− Language.Reflection.Elab and the %runElab constructs
60−* The --ideslave command line option has been replaced with a --ide-mode
61− command line option with the same semantics.
62−* A new tactic "claim N TY" that introduces a new hole named N with type TY
63−* A new tactic "unfocus" that moves the current hole to the bottom of the
65−* Quasiquotation supports the generation of Language.Reflection.Raw terms
66− in addition to Language.Reflection.TT. Types are used for disambiguation,
67− defaulting to TT at the REPL.
68−* Language.Reflection.Quotable now takes an extra type parameter which
69− determines the type to be quoted to. Instances are provided to quote
70− common types to both TT and Raw.
71−* Library operators have been renamed for consistency with Haskell. In
72− particular, Applicative.(<$>) is now Applicative.(<*>) and (<$>) is
73− now an alias for Functor.map. Correspondingly, ($>) and (<$) have
74− been renamed to (<*) and (*>). The cascading effects of this rename
75− are that Algebra.(<*>) has been renamed to Algebra.(<.>) and
76− Matrix.(<.>) is now Matrix.(<:>).
77−* Binding forms in DSL notation are now given an extra argument: a
78− reflected representation of the name that the user chose.
79− Specifically, the rewritten lambda, pi, and let binders will now get
80− an extra argument of type TTName. This allows more understandable
81− dynamic errors in DSL code and more readable code generation results.
82−* DSL notation can now be applied with $
83−* Added FFI_Export type which allows Idris functions to be exportoed and
84− called from foreign code
85−* Instances can now have documentation strings.
86−* Type providers can have documentation strings.
87−* Unification errors now (where possible) contain information about provenance
89−* New REPL command ":core TM" that shows the elaborated form of TM along with
90− its elaborated type using the syntax of TT. IDE mode has a corresponding
91− command :elaborate-term for serialized terms.
92−* Effectful and IO function names for sending data to STDOUT have been
93− aligned, semantically.
94− + `print` is now for putting showable things to STDOUT.
95− + `printLn` is for putting showable things to STDOUT with a new line
96− + `putCharLn` for putting a single character to STDOUT, with a new line.
97−* Classes can now be annotated with 'determining parameters' to say which
98− must be available before resolving instances. Only determining parameters
99− are checked when checking for overlapping instances.
100−* New package 'contrib' containing things that are less mature or less used
101− than the contents of 'base'. 'contrib' is not available by default, so you
102− may need to add '-p contrib' to your .ipkg file or Idris command line.
103−* Arguments to class instances are now checked for injectivity.
104− Unification assumes this, so we need to check when instances are defined.
108−* Inductive-inductive definitions are now supported (i.e. simultaneously
109− defined types where one is indexed by the other.)
110−* Implicits and type class constraints can now appear in scopes other than
112−* Importing a module no longer means it is automatically reexported. A new
113− "public" modifier has been added to import statements, which will reexport
114− the names exported from that module.
115−* Implemented @-patterns. A pattern of the form x@p on the left hand side
116− matches p, with x in scope on the right hand side with value p.
117−* A new tactic sourceLocation that fills the current hole with the current
118− source code span, if this information is available. If not, it raises an
120−* Better Unicode support for the JavaScript/Node codegen
121−* ':search' and ':apropos' commands can now be given optional package lists
123−* Vect, Fin and So moved out of prelude into base, in modules Data.Vect,
124− Data.Fin and Data.So respectively.
125−* Several long-standing issues resolved, particularly with pattern matching
126− and coverage checking.
127−* Modules can now have API documentation strings.
131−* Two new tactics: skip and fail. Skip does nothing, and fail takes a string
132− as an argument and produces it as an error.
133−* Corresponding reflected tactics Skip and Fail. Reflected Fail takes a list
134− of ErrorReportParts as an argument, like error handlers produce, allowing
135− access to the pretty-printer.
136−* Stop showing irrelevant and inaccessible internal names in the interactive
138−* The proof arguments in the List library functions are now implicit and
139− solved automatically.
140−* More efficient representation of proof state, leading to faster elaboration
141− of large expressions.
142−* EXPERIMENTAL Implementation of uniqueness types
143−* Unary negation now desugars to "negate", which is a method of the Neg type class.
144− This allows instances of Num that can't be negative, like Nat, and it makes correct
145− IEEE Float operations easier to encode. Additionally, unary negation is now available
147−* The Java and LLVM backends have been factored out for separate maintenance. Now, the
148− compiler distribution only ships with the C and JavaScript backends.
149−* New REPL command :printdef displays the internal definition of a name
150−* New REPL command :pprint pretty-prints a definition or term with LaTeX or
152−* Naming of data and type constructors is made consistent across the standard
154−* Terms in `code blocks` inside of documentation strings are now parsed and
155− type checked. If this succeeds, they are rendered in full color in
156− documentation lookups, and with semantic highlighting for IDEs.
157−* Fenced code blocks in docs defined with the "example" attribute are rendered
159−* Fenced code blocks declared to be Idris code that fail to parse or type check now
160− provide error messages to IDE clients.
161−* EXPERIMENTAL support for partial evaluation (Scrapping your Inefficient
166−* Tactic for case analysis in proofs
167−* Induction and case tactic now work on expressions
168−* Support for running tests for a package with the tests section of .ipkg files and the
169− --testpkg command-line option
170−* Clearly distinguish between type providers and postulate providers at the use site
171−* Allow dependent function syntax to be overridden in dsl blocks, similarly to
172− functions and let. The keyword for this is "pi".
173−* Updated 'effects' library, with simplified API
174−* All new JavaScript backend (avoids callstack overflows)
175−* Add support for %lib directive for NodeJS
176−* Quasiquotes and quasiquote patterns allow easier work with reflected terms.
177− `(EXPR) quasiquotes EXPR, causing the elaborator to be used to produce a reflected
178− version of it. Subterms prefixed with ~ are unquoted - on the RHS, they are reflected
179− terms to splice in, while on the LHS they are patterns.
180− A quasiquote expression can be given a goal type for the elaborator, which helps with
181− disambiguation. For instance, `(() : ()) quotes the unit constructor, while `(() : Type)
182− quotes the unit type.
183− Both goal types and quasiquote are typechecked in the global environment.
184−* Better inference of unbound implicits
188−* IDE support for retrieving structured information about metavariables
189−* Experimental Bits support for JavaScript
190−* IdrisDoc: a Haddock- and JavaDoc-like HTML documentation generator
191−* Command line option -e (or --eval) to evaluate expressions without loading the
192− REPL. This is useful for writing more portable tests.
193−* Many more of the basic functions and datatypes are documented.
194−* Primitive types such as Int and String are documented
195−* Removed javascript lib in favor of idris-hackers/iQuery
196−* Specify codegen for :compile REPL command (e.g. :compile javascript program.js)
197−* Remove :info REPL command, subsume and enhance its functionality in the :doc command
198−* New (first class) nested record update/access syntax:
199− record { a->b->c = val } x -- sets field accessed by c (b (a x)) to val
200− record { a->b->c } x -- accesses field, equivalent to c (b (a x))
201−* The banner at startup can be suppressed by adding :set nobanner to the initialisation script.
202−* :apropos now accepts space-delimited lists of query items, and searches for the conjunction
203− of its inputs. It also accepts binder syntax as search strings - for instance, -> finds
205−* Totality errors are now treated as warnings until code generation time, when they become
206− errors again. This allows users to use the interactive editing features to fix totality
207− issues, but no programs that violate the stated assumptions will actually run.
208−* Added :makelemma command, which adds a new top level definition to solve
210−* Extend :addclause to add instance bodies as well as definitions
211−* Reverse parameters to BoundedList -- now matches Vect, and is easier to instantiate classes.
212−* Move foldl into Foldable so it can be overridden.
213−* Experimental :search REPL command for finding functions by type
217−* New implementation of erasure
222−* Proof search now works for metavariables in types, giving some interactive
224−* New 'Lazy' type, replacing laziness annotations.
225−* JavaScript and Node codegen now understand the %include directive.
226−* Concept of 'null' is now understood in the JavaScript and Node codegen.
227−* Lots of performance patches for generated JavaScript.
228−* New commands :eval (:e) and :type (:t) in the prover, which either normalise
229− or show the type of expressions.
230−* Allow type providers to return postulates in addition to terms.
231−* Syntax for dealing with match failure in <- and pattern matching let.
232−* New syntax for inline documentation. Documentation starts with |||, and
233− arguments are documented by preceding their name with @. Example:
234− ||| Add two natural numbers
235− ||| @ n the first number (examined by the function)
236− ||| @ m the second number (not examined)
237− plus (n, m : Nat) -> Nat
238−* Allow the auto-solve behaviour in the prover to be disabled, for easier
239− debugging of proof automation. Use ":set autosolve" and ":unset autosolve".
240−* Updated 'effects' library
241−* New :apropos command at REPL to search documentation, names, and types
242−* Unification errors are now slightly more informative
243−* Support mixed induction/coinduction with 'Inf' type
244−* Add 'covering' function option, which checks whether a function and all
245− descendants cover all possible inputs
250−* Agda-style equational reasoning (in Syntax.PreorderReasoning)
251−* 'case' construct now abstracts over the scrutinee in its type
252−* Added label type 'name (equivalent to the empty type).
253− This is intended for field/effect disambiguation. "name" can be any
254− valid identifier. Two labels are definitionally equal if they have the
256−* General improvements in error messages, especially %error_reverse
257− annotation, which allows a hint as to how to display a term in error
259−* --ideslave mode now transmits semantic information about many of the
260− strings that it emits, which can be used by clients to implement
261− semantic highlighting like that of the REPL. This has been implemented
262− in the Emacs mode and the IRC bot, which can serve as examples.
263−* New expression form: with NAME EXPR privileges the namespace NAME
264− when disambiguating overloaded names. For example, it is possible to
265− write "with Vect [1,2,3]" at the REPL instead of "the (Vect _ _) [1,2,3]",
266− because the Vect constructors are defined in a namespace called Vect.
267−* assert_smaller internal function, which marks an expression as smaller than
268− a pattern for use in totality checking.
269− e.g. "assert_smaller (x :: xs) (f xs)" asserts that "f xs" will always be
270− structurally smaller than "(x :: xs)"
271−* assert_total internal function, which marks a subexpression as assumed to
272− be total, e.g "assert_total (tail (x :: xs))".
273−* Terminal width is automatically detected if Idris is compiled with curses
274− support. If curses is not available, automatic mode assumes 80 columns.
275−* Changed argument order for Prelude.Either.either.
276−* Experimental 'neweffects' library, intended to replace 'effects' in the
283−* Pretty-printer now used for all term output
289−* Type classes now implemented as dependent records, meaning that method
290− types may now depend on earlier methods.
291−* More flexible class instance resolution, so that function types and lambda
292− expressions can be made instances of a type class.
293−* Add !expr notation for implicit binding of intermediate results in
294− monadic/do/etc expressions.
295−* Extend Effects package to cope with possibly failing operations, using
296− "if_valid", "if_error", etc.
297−* At the REPL, "it" now refers to the previous expression.
298−* Semantic colouring at the REPL. Turn this off with --nocolour.
299−* Some prettifying of error messages.
300−* The contents of ~/.idris/repl/init are run at REPL start-up.
301−* The REPL stores a command history in ~/.idris/repl/history.
302−* The [a..b], [a,b..c], [a..], and [a,b..] syntax now pass the totality
303− checker and can thus be used in types. The [x..] syntax now returns an
304− actually infinite stream.
305−* Add '%reflection' option for functions, for compile-time operations on
307−* Add expression form 'quoteGoal x by p in e' which applies p to the expected
308− expression type and binds the result to x in the scope e.
309−* Performance improvements in Strings library.
310−* Library reorganisation, separated into prelude/ and base/.
314−* New module/dependency tree checking.
315−* New parser implementation with more precise errors.
316−* Improved type class resolution.
317−* Compiling Nat via GMP integers.
318−* Performance improvements in elaboration.
319−* Improvements in termination checking.
320−* Various REPL commands to support interactive editing, and a client/server
321− mode to allow external invocation of REPL commands.
326−* Apply functions by return type, rather than with arguments:
327− "t <== f" means "apply f with arguments such that it returns a value
329−* Allow the result type of a rewrite to be specified
330−* Allow names to be attached to provisional definitions
331− lhs ?= {name} rhs -- generates a lemma called 'name' which makes the
332− types of the lhs and rhs match. {name} is optional - a unique name is
333− generated if it is absent.
334−* Experimental LLVM backend
335−* Added Data.HVect module
336−* Fix fromInteger to take an Integer, rather than an Int
337−* Integer literals for Fin
338−* Renamed O to Z, and fO to fZ
339−* Swapped Vect arguments, now Vect : Nat -> Type -> Type
340−* Added DecEq instances
341−* Add 'equiv' tactic, which rewrites a goal to an equivalent (convertible) goal
345−* Add annotation for unification traces
346−* Add 'mrefine' tactic for refining by matching against a type
347−* Type class resolution fixes
348−* Much faster coverage checking
353−User visible changes:
355−* Added "rewrite ... in ..." construct
356−* Allow type class constraints in 'using' clauses
357−* Renamed EFF to EFFECT in Effect package
358−* Experimental Java backend
359−* Tab completion in REPL
360−* Dynamic loading of C libraries in the interpreter
361−* Testing IO actions at the REPL with :x command
362−* Improve rendering of :t
363−* Fixed some INTERNAL ERROR messages
367−* Fix non-linear pattern checking
368−* Improved name disambiguation
369−* More flexible unification and elaboration of lambdas
370−* Various unification and totality checking bug fixes
375−User visible changes:
377−* 'implicit' keyword, for implicit type conversion
378−* Added Effects package
379−* Primitives for 8,16,32 and 64 bit integers
383−* Change unification so that it keeps track of failed constraints in case
384− later information helps to resolve them
385−* Distinguishing parameters and indices in data types
386−* Faster termination/coverage checking
387−* Split 'javascript' target into 'javascript' and 'node'
392−User visible changes:
394−* The type of types is now 'Type' rather than 'Set'
395−* Forward declarations of data allowed
396− - supporting induction recursion and mutually recursive data
397−* Type inference of definitions in 'where' clauses
398− - Provided that the type can be completely determined from the first
399− application of the function (in the top level definition)
400−* 'mutual' blocks added
401− - effect is to elaborate all types of declarations in the block before
402− elaborating their definitions
403− - allows inductive-recursive definitions
404−* Expression inspected by 'with' clause now abstracted from the goal
406−* Implicit arguments will be added automatically only if their initial
407− letter is lower case, or they are in a using declaration
408−* Added documentation comments (Haddock style) and ':doc' REPL command
409−* Pattern matching on strings, big integers and characters
410−* Added System.Concurrency modules
411−* Added 'postulate' declarations
412−* Allow type annotations on 'let' tactic
413−* EXPERIMENTAL JavaScript generation, with '--target javascript' option
417−* Separate inlining methods at compile-time and run-time
418−* Fixed nested parameters blocks
419−* Improve efficiency of elaborator by:
420− - only normalising when necessary
421− - reducing backtracking with resolving ambiguities
422−* Better compilation of case trees
427−User visible changes:
430− - as data declarations, but constructor arguments are evaluated lazily
431− - functions which return a codata type do not reduce at compile time
432−* Added 'parameters' blocks
433−* Allow local data definitions in where blocks
434−* Added '%default' directive to declare total-by-default or partial-by-default
435− for functions, and a corresponding "partial" reserved words to mark functions
436− as allowed to be partial. Also "--total" and "--partial" added as command
438−* Command line option "--warnpartial" for flagging all undeclared
439− partial functions, without error.
440−* New termination checker supporting mutually recursive definitions.
441−* Added ':load' command to REPL, for loading a new file
442−* Added ':module' command to REPL, for adding modules
443−* Renamed library modules (now have initial capital)
447−* Several improvements and fixes to unification
448−* Added collapsing optimisation and more aggressive erasure
453−User visible changes:
455−* Simple packaging system
456−* Added --dumpc flag for displaying generated code
460−* Improve overloading resolution (especially where this is a type error)
461−* Various important bug fixes with evaluation and compilation
462−* More aggressive compile-time evaluation
467−User visible changes:
469−* Added binding forms to syntax rules
470−* Named class instances
471−* Added ':set' command, with options 'errorcontext' for displaying local
472− variables in scope when a unification error occurs, and 'showimplicits'
473− for displaying elaborated terms in full
474−* Added '--errorcontext' command line switch
475−* Added ':proofs' and ':rmproofs' commands
476−* Various minor REPL improvements and fixes
480−* Completely new run time system (not based on Epic or relying on Boehm GC)
481−* Normalise before forcing to catch more forceable arguments
482−* Types no longer exported in normal form
483−* Try to resolve overloading by inspecting types, rather than full type
489−User visible changes:
491−* backtick notation added: x `foo` y ==> foo x y
492−* case expressions allowed in type signatures
493−* Library extensions in prelude.vect and prelude.algebra
494−* malloc/trace_malloc added to builtins.idr
498−* Some type class resolution fixes
499−* Several minor bug fixes
500−* Performance improvements in resolving overloading and type classes
505−User visible changes:
507−* DSL notation, for overloading lambda and let bindings
508−* Dependent records, with projection and update
509−* Totality checking and 'total' keyword
510−* Auto implicits and default argument values {auto n : T}, {default val n : T}
511−* Overlapping type class instances disallowed
512−* Many extensions to prelude.nat and prelude.list libraries (mostly thanks to
514−* New libraries: control.monad.identity, control.monad.state
515−* Small improvements in error reporting
519−* Faster compilation (only compiling names which are used)
520−* Better type class resolution
521−* Lots of minor bug fixes
525−Complete rewrite. User visible changes:
527−* New proof/tactics syntax
528−* New syntax for pairs/dependent pairs
529−* Indentation-significant syntax
531−* Added where clauses
532−* Added case expressions, pattern matching let and lambda
533−* Added monad comprehensions
534−* Added cumulativity and universe checking
535−* Ad-hoc name overloading
536− - Resolved by type or explicit namespace
537−* Modules (Haskell-style)
538−* public, abstract and private access to functions and types
539−* Separate type-checking
540−* Improved interactive environment
541−* Replaced 'do using' with Monad class
542−* Extended syntax macros
547−* All definitions (functions, classes and instances) are elaborated to top
548− level, fully explicit, data declarations and pattern matching definitions,
549− which are verified by a minimal type checker.
551−This is the first release of a complete reimplementation. There will be bugs.
552−If you find any, please do not hesitate to contact Edwin Brady
553−(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).
@@ -17,7 +17,7 @@ If you use `Idris` in your work we would prefer it if you would use the followin
17 pages = {552--593},
17 pages = {552--593},
18 numpages = {42},
18 numpages = {42},
19 doi = {10.1017/S095679681300018X},
19 doi = {10.1017/S095679681300018X},
20− URL = {http://journals.cambridge.org/article_S095679681300018X},
20+ URL = {https://journals.cambridge.org/article_S095679681300018X},
@@ -6,9 +6,9 @@ Here are a few guidelines that we would like contributors to follow so that we c
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).
121. Make sure you can install Idris:
121. 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)
@@ -20,6 +20,21 @@ Here are a few guidelines that we would like contributors to follow so that we c
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
25We try to follow the **campsite rule**: leave the code base in better condition than you found it.
40We try to follow the **campsite rule**: leave the code base in better condition than you found it.
@@ -49,7 +64,7 @@ Major changes to the library, or Idris itself, should be discussed first through
501. The mailing List.
651. The mailing List.
511. On our IRC Channel `#idris` on freenode, or
661. On our IRC Channel `#idris` on freenode, or
52−1. As a [Dragon Egg](https://github.com/idris-lang/Idris-dev/wiki/Feature-proposals).
67+1. As an RFC in the issue tracker
54Developers 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.
69Developers 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.
@@ -57,7 +72,7 @@ We do not want you wasting your time nor duplicating somebody's work!
58## Making Changes
73## Making Changes
60−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/).
61The steps are described below.
76The steps are described below.
63### New contributors
78### New contributors
@@ -68,7 +83,7 @@ For those new to the project:
682. Clone your fork to your local machine:
832. Clone your fork to your local machine:
71−$ 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
743. Add `idris-lang/Idris-dev` as a remote upstream
893. Add `idris-lang/Idris-dev` as a remote upstream
@@ -157,13 +172,13 @@ To help increase the chance of your pull request being accepted:
158* [Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki);
173* [Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki);
159* [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);
160−* 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);
161* [Idris Manual](https://github.com/idris-lang/Idris-dev/wiki/Manual);
176* [Idris Manual](https://github.com/idris-lang/Idris-dev/wiki/Manual);
162−* [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);
163−* [Idris News](http://www.idris-lang.org/news/);
178+* [Idris News](https://www.idris-lang.org/news/);
164−* [other Idris docs](http://www.idris-lang.org/documentation/).
179+* [other Idris docs](https://www.idris-lang.org/documentation/).
165* [Using Pull Requests](https://help.github.com/articles/using-pull-requests)
180* [Using Pull Requests](https://help.github.com/articles/using-pull-requests)
166* [General GitHub Documentation](https://help.github.com/).
181* [General GitHub Documentation](https://help.github.com/).
169−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,43 +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−Jan Bessai
10+Alex Feldman-Crough
7−Michael R. Bernstein
11+Alex S. Queiroz e Silva
8−Nicola Botta
12+Alexander Berntsen
9−Edwin Brady
13+Alexander Shabalin
11Alyssa Carter
14Alyssa Carter
12−David Raymond Christiansen
15+Andreas Bogk
23+Apostolis Xekoukoulotakis
13Carter Charbonneau
40Carter Charbonneau
14−Jason Dagit
41+Casper M. H. Holmgreen
15−Simon Fowler
42+cchantep
17Cezar Ionescu
43Cezar Ionescu
60+David Raymond Christiansen
18Irene Knapp
102Irene Knapp
19−Paul Koerbitz
103+Jack Henahan
20−Niklas Larsson
104+Jacob Mitchell
21−Shea Levy
105+Jakob Brünker
107+Jan de Muijnck-Hughes
22Mathnerd314
147Mathnerd314
23−Hannes Mehnert
148+Mattias Lundell
24Mekeor Melire
152Mekeor Melire
25Melissa Mozifian
153Melissa Mozifian
26−Dominic Mulligan
154+Melvar Chen
27−Jan de Muijnck-Hughes
155+Michael A. Smith
28−Tom Prince
156+Michael Bernstein
29−raichoo
157+Michael Gilliland
30Philip Rasmussen
179Philip Rasmussen
31−Reynir Reynisson
180+PoroCYon
32−Adam Sandberg Eriksson
181+raichoo
193+Sebastian de Bellefon
33Seo Sanghyeon
195Seo Sanghyeon
34−Benjamin Saunders
196+Sergei Trofimovich
35−Alexander Shabalin
197+Shane Pearman
38−Chetan T
201+Stefan Bleibinhaus
39−Matúš Tejiščák
202+stepcut
40−Dirk Ullrich
203+Stephen Drodge
41−Leif Warner
204+Steven Shaw
42−Daniel Waterworth
205+Stuart Gale
43−Jonas Westerlund
206+suhorng
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,53 +1,62 @@
1−.PHONY: build configure doc install linecount nodefault pinstall lib_clean relib test_c test lib_doc lib_doc_clean user_doc_html user_doc_pdf user_docs
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
7CABALFLAGS += -f CI
11CABALFLAGS += -f CI
13+TEST-ARGS += --color always
11− $(CABAL) install $(CABALFLAGS)
18+ $(CABAL) v1-install $(CABALFLAGS)
13pinstall: CABALFLAGS += --enable-executable-profiling
20pinstall: CABALFLAGS += --enable-executable-profiling
14pinstall: dist/setup-config
21pinstall: dist/setup-config
15− $(CABAL) install $(CABALFLAGS)
22+ $(CABAL) v1-install $(CABALFLAGS)
17build: dist/setup-config
24build: dist/setup-config
18− $(CABAL) build $(CABALFLAGS)
25+ $(CABAL) v1-build $(CABALFLAGS)
20−test: doc test_c
27+test: doc test_c stylize
23− $(MAKE) -C test IDRIS=../dist/build/idris
26− $(MAKE) -C test IDRIS=../dist/build/idris test_java
30+ ./stylize.sh
29− $(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"
32− $(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"
34−test_all:
44+test_clean:
35− $(MAKE) test
45+ rm -f test/*~
36− $(MAKE) test_llvm
46+ rm -f test/*/output
40 $(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
42relib: lib_clean
51relib: lib_clean
43− $(CABAL) install $(CABALFLAGS)
52+ $(CABAL) v1-install $(CABALFLAGS)
46− wc -l src/Idris/*.hs src/Idris/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
48#Note: this doesn't yet link to Hackage properly
57#Note: this doesn't yet link to Hackage properly
49doc: dist/setup-config
58doc: dist/setup-config
50− $(CABAL) haddock --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"
53 $(MAKE) -C libs IDRIS=../../dist/build/idris/idris doc
62 $(MAKE) -C libs IDRIS=../../dist/build/idris/idris doc
@@ -66,5 +75,8 @@ user_doc_html:
66user_doc_pdf:
75user_doc_pdf:
67 $(MAKE) -C docs latexpdf
76 $(MAKE) -C docs latexpdf
79+ $(CABAL) v1-install $(CABALFLAGS) --ghc-option=-O0
69dist/setup-config:
81dist/setup-config:
70− $(CABAL) configure $(CABALFLAGS)
82+ $(CABAL) v1-configure $(CABALFLAGS)
@@ -1,56 +1,26 @@
3[](https://travis-ci.org/idris-lang/Idris-dev)
3[](https://travis-ci.org/idris-lang/Idris-dev)
4+[](https://ci.appveyor.com/project/idrislang/idris-dev)
4[](https://readthedocs.org/projects/idris/?badge=latest)
5[](https://readthedocs.org/projects/idris/?badge=latest)
5−[](https://hackage.haskell.org/package/idris)
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)
7−Idris (http://idris-lang.org/) is a general-purpose functional programming
11+Idris (https://idris-lang.org/) is a general-purpose functional programming
8language with dependent types.
12language with dependent types.
10−## Standard Installation Instructions
14+## Installation Guides.
11−This repository represents the latest development version of the language,
12−and may contain bugs that are being actively worked on.
13−For those who wish to use a more stable version of Idris please consider
14−installing the latest version that has been released on Hackage.
15−Installation instructions for various platforms can be [found on the Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki/Installation-Instructions).
17−## Installing Development Versions
19−If you like to work against the latest development version, please consider
20−using Cabal Sandboxes to minimise disruption to your local Haskell setup.
21−Instructions for installing Idris HEAD within a cabal sandbox are
22−[available on the Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki/Installing-an-Idris-Development-version-in-a-sandbox).
24−To configure, edit config.mk. The default values should work for most people.
26−Idris is built using a Makefile common targets include:
28−* `make` This will install everything using cabal and
29−typecheck the libraries.
30−* `make test` This target execute the test suite.
31−* `make relib` This target will typecheck and recompile the standard library.
33−Idris has an optional buildtime dependency on the C library `libffi`. If you
34−would like to use the features that it enables, make sure that it is compiled
35−for the same architecture as your Haskell compiler (e.g. 64 bit libraries
36−for 64 bit ghc). By default, Idris builds without it. To build with it, pass
39−To build with `libffi` by default, create a `custom.mk` file and add the
16+This repository represents the latest development version of the
40−following line to it:
17+language, and may contain bugs that are being actively worked on. For
41−
18+those who wish to use a more stable version of Idris please consider
42−`CABALFLAGS += -f FFI`
19+installing the latest version that has been released on Hackage.
43−
20+Installation instructions for various platforms can be
44−The file custom.mk-alldeps is a suitable example.
21+[found on the Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki/Installation-Instructions).
46−The continuous integration builds on travis-ci.org are built using the
47−ghc-flag -Werror. To enable this behaviour locally also, please compile
48−using `make CI=true` or adding the following line into `custom.mk`:
52−If you are only compiling for installing the most current version, you can
23+More information about building Idris from source has been detailed in the [Installation Guide](INSTALL.md)
53−omit the CI flag, but please make sure you use it if you want to contribute.
55## Code Generation
25## Code Generation
@@ -58,9 +28,7 @@ Idris has support for external code generators. Supplied with the distribution
58is a C code generator to compile executables, and a JavaScript code generator
28is a C code generator to compile executables, and a JavaScript code generator
59with support for node.js and browser JavaScript.
29with support for node.js and browser JavaScript.
61−At this moment in time there are two external repositories with a
31+More information about [code generators can be found on the wiki](https://idris.readthedocs.io/en/latest/reference/codegen.html).
62−[Java code generator](https://github.com/idris-hackers/idris-java) and an
63−[LLVM-based code generator](https://github.com/idris-hackers/idris-llvm).
65## More Information
33## More Information
@@ -76,3 +44,6 @@ where some interesting projects are being hosted.
77For those interested in contributing to Idris directly we kindly ask that
45For those interested in contributing to Idris directly we kindly ask that
78prospective developers please consult the [Contributing Guide](CONTRIBUTING.md) first.
46prospective 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,17 +1,24 @@
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
16import System.Environment
23import System.Environment
17import System.Exit
24import System.Exit
@@ -20,6 +27,11 @@ import System.Directory
20import qualified System.FilePath.Posix as Px
27import qualified System.FilePath.Posix as Px
21import System.Process
28import System.Process
30+#if (MIN_VERSION_Cabal(2,0,0))
31+import Distribution.Types.UnqualComponentName
23-- 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
25-- -----------------------------------------------------------------------------
37-- -----------------------------------------------------------------------------
@@ -37,7 +49,8 @@ idrisCmd local = ".." </> ".." </> buildDir local </> "idris" </> "idris"
37-- Make Commands
49-- Make Commands
39-- use GNU make on FreeBSD
51-- use GNU make on FreeBSD
40−#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)
41mymake = "gmake"
54mymake = "gmake"
43mymake = "make"
56mymake = "make"
@@ -45,50 +58,61 @@ mymake = "make"
45make verbosity =
58make verbosity =
46 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"
48-- -----------------------------------------------------------------------------
64-- -----------------------------------------------------------------------------
51usesGMP :: S.ConfigFlags -> Bool
67usesGMP :: S.ConfigFlags -> Bool
52usesGMP flags =
68usesGMP flags =
53− case lookup (FlagName "gmp") (S.configConfigurationsFlags flags) of
69+ case lookupFlagAssignment (mkFlagName "gmp") (S.configConfigurationsFlags flags) of
54 Just True -> True
70 Just True -> True
55 Just False -> False
71 Just False -> False
56− Nothing -> True
72+ Nothing -> False
58execOnly :: S.ConfigFlags -> Bool
74execOnly :: S.ConfigFlags -> Bool
59execOnly flags =
75execOnly flags =
60− case lookup (FlagName "execonly") (S.configConfigurationsFlags flags) of
76+ case lookupFlagAssignment (mkFlagName "execonly") (S.configConfigurationsFlags flags) of
61 Just True -> True
77 Just True -> True
62 Just False -> False
78 Just False -> False
63 Nothing -> False
79 Nothing -> False
65isRelease :: S.ConfigFlags -> Bool
81isRelease :: S.ConfigFlags -> Bool
66isRelease flags =
82isRelease flags =
67− case lookup (FlagName "release") (S.configConfigurationsFlags flags) of
83+ case lookupFlagAssignment (mkFlagName "release") (S.configConfigurationsFlags flags) of
68 Just True -> True
84 Just True -> True
69 Just False -> False
85 Just False -> False
70 Nothing -> False
86 Nothing -> False
72isFreestanding :: S.ConfigFlags -> Bool
88isFreestanding :: S.ConfigFlags -> Bool
73isFreestanding flags =
89isFreestanding flags =
74− case lookup (FlagName "freestanding") (S.configConfigurationsFlags flags) of
90+ case lookupFlagAssignment (mkFlagName "freestanding") (S.configConfigurationsFlags flags) of
75 Just True -> True
91 Just True -> True
76 Just False -> False
92 Just False -> False
77 Nothing -> False
93 Nothing -> False
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
78-- -----------------------------------------------------------------------------
105-- -----------------------------------------------------------------------------
81−idrisClean _ flags _ _ = do
108+idrisClean _ flags _ _ = cleanStdLib
84 verbosity = S.fromFlag $ S.cleanVerbosity flags
110 verbosity = S.fromFlag $ S.cleanVerbosity flags
87− makeClean "libs"
112+ cleanStdLib = makeClean "libs"
89 makeClean dir = make verbosity [ "-C", dir, "clean", "IDRIS=idris" ]
114 makeClean dir = make verbosity [ "-C", dir, "clean", "IDRIS=idris" ]
92-- -----------------------------------------------------------------------------
116-- -----------------------------------------------------------------------------
93-- Configure
117-- Configure
@@ -97,15 +121,27 @@ gitHash = do h <- Control.Exception.catch (readProcess "git" ["rev-parse", "--sh
97 (\e -> let e' = (e :: SomeException) in return "PRE")
121 (\e -> let e' = (e :: SomeException) in return "PRE")
98 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
100-- 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
101-- For release builds, just put the empty string in the module
137-- For release builds, just put the empty string in the module
102generateVersionModule verbosity dir release = do
138generateVersionModule verbosity dir release = do
103 hash <- gitHash
139 hash <- gitHash
104 let versionModulePath = dir </> "Version_idris" Px.<.> "hs"
140 let versionModulePath = dir </> "Version_idris" Px.<.> "hs"
105 putStrLn $ "Generating " ++ versionModulePath ++
141 putStrLn $ "Generating " ++ versionModulePath ++
106− if release then " for release" else (" for prerelease " ++ hash)
142+ if release then " for release" else " for prerelease " ++ hash
107 createDirectoryIfMissingVerbose verbosity True dir
143 createDirectoryIfMissingVerbose verbosity True dir
108− rewriteFile versionModulePath (versionModuleContents hash)
144+ rewriteFileEx verbosity versionModulePath (versionModuleContents hash)
110 where versionModuleContents h = "module Version_idris where\n\n" ++
146 where versionModuleContents h = "module Version_idris where\n\n" ++
111 "gitHash :: String\n" ++
147 "gitHash :: String\n" ++
@@ -115,11 +151,11 @@ generateVersionModule verbosity dir release = do
116-- Generate a module that contains the lib path for a freestanding Idris
152-- Generate a module that contains the lib path for a freestanding Idris
117generateTargetModule verbosity dir targetDir = do
153generateTargetModule verbosity dir targetDir = do
118− absPath <- return $ isAbsolute targetDir
154+ let absPath = isAbsolute targetDir
119 let targetModulePath = dir </> "Target_idris" Px.<.> "hs"
155 let targetModulePath = dir </> "Target_idris" Px.<.> "hs"
120 putStrLn $ "Generating " ++ targetModulePath
156 putStrLn $ "Generating " ++ targetModulePath
121 createDirectoryIfMissingVerbose verbosity True dir
157 createDirectoryIfMissingVerbose verbosity True dir
122− rewriteFile targetModulePath (versionModuleContents absPath targetDir)
158+ rewriteFileEx verbosity targetModulePath (versionModuleContents absPath targetDir)
123 where versionModuleContents absolute td = "module Target_idris where\n\n" ++
159 where versionModuleContents absolute td = "module Target_idris where\n\n" ++
124 "import System.FilePath\n" ++
160 "import System.FilePath\n" ++
125 "import System.Environment\n" ++
161 "import System.Environment\n" ++
@@ -145,22 +181,26 @@ generateToolchainModule verbosity srcDir toolDir = do
145 "getToolchainDir = \"\""
181 "getToolchainDir = \"\""
146 let toolPath = srcDir </> "Tools_idris" Px.<.> "hs"
182 let toolPath = srcDir </> "Tools_idris" Px.<.> "hs"
147 createDirectoryIfMissingVerbose verbosity True srcDir
183 createDirectoryIfMissingVerbose verbosity True srcDir
148− rewriteFile toolPath (commonContent ++ toolContent)
184+ rewriteFileEx verbosity toolPath (commonContent ++ toolContent)
150−idrisConfigure _ flags _ local = do
186+idrisConfigure _ flags pkgdesc local = do
151 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
152− generateVersionModule verbosity (autogenModulesDir local) (isRelease (configFlags local))
192+ generateVersionModule verbosity libAutogenDir (isRelease (configFlags local))
153− if (isFreestanding $ configFlags local)
193+ if isFreestanding $ configFlags local
154− then (do
194+ then do
155− toolDir <- lookupEnv "IDRIS_TOOLCHAIN_DIR"
195+ toolDir <- lookupEnv "IDRIS_TOOLCHAIN_DIR"
156− generateToolchainModule verbosity (autogenModulesDir local) toolDir
196+ generateToolchainModule verbosity libAutogenDir toolDir
157− targetDir <- lookupEnv "IDRIS_LIB_DIR"
197+ targetDir <- lookupEnv "IDRIS_LIB_DIR"
158− case targetDir of
198+ case targetDir of
159− Just d -> generateTargetModule verbosity (autogenModulesDir local) d
199+ Just d -> generateTargetModule verbosity libAutogenDir d
160− Nothing -> error $ "Trying to build freestanding without a target directory."
200+ Nothing -> error $ "Trying to build freestanding without a target directory."
161− ++ " Set it by defining IDRIS_LIB_DIR.")
201+ ++ " Set it by defining IDRIS_LIB_DIR."
163− generateToolchainModule verbosity (autogenModulesDir local) Nothing
203+ generateToolchainModule verbosity libAutogenDir Nothing
165 verbosity = S.fromFlag $ S.configVerbosity flags
205 verbosity = S.fromFlag $ S.configVerbosity flags
166 version = pkgVersion . package $ localPkgDescr local
206 version = pkgVersion . package $ localPkgDescr local
@@ -171,23 +211,14 @@ idrisConfigure _ flags _ local = do
171 -- the file after configure.
211 -- the file after configure.
172 configureRTS = make verbosity ["-C", "rts", "clean"]
212 configureRTS = make verbosity ["-C", "rts", "clean"]
174−idrisPreSDist args flags = do
214+#if !(MIN_VERSION_Cabal(2,0,0))
175− let dir = S.fromFlag (S.sDistDirectory flags)
215+ autogenComponentModulesDir lbi _ = autogenModulesDir lbi
176− let verb = S.fromFlag (S.sDistVerbosity flags)
216+#endif
177− generateVersionModule verb ("src") True
217+
178− generateTargetModule verb "src" "./libs"
218+#if !(MIN_VERSION_Cabal(2,0,0))
179− generateToolchainModule verb "src" Nothing
219+rewriteFileEx :: Verbosity -> FilePath -> String -> IO ()
180− preSDist simpleUserHooks args flags
220+rewriteFileEx _ = rewriteFile
182−idrisPostSDist args flags desc lbi = do
183− Control.Exception.catch (do let file = "src" </> "Version_idris" Px.<.> "hs"
184− let targetFile = "src" </> "Target_idris" Px.<.> "hs"
185− putStrLn $ "Removing generated modules:\n "
186− ++ file ++ "\n" ++ targetFile
188− removeFile targetFile)
189− (\e -> let e' = (e :: SomeException) in return ())
190− postSDist simpleUserHooks args flags desc lbi
192-- -----------------------------------------------------------------------------
223-- -----------------------------------------------------------------------------
@@ -198,9 +229,27 @@ getVersion args flags = do
198 let buildinfo = (emptyBuildInfo { cppOptions = ["-DVERSION="++hash] }) :: BuildInfo
229 let buildinfo = (emptyBuildInfo { cppOptions = ["-DVERSION="++hash] }) :: BuildInfo
199 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, [])
201−idrisBuild _ flags _ local = unless (execOnly (configFlags local)) $ do
249+idrisBuild _ flags _ local
250+ = if (execOnly (configFlags local)) then buildRTS
202− buildStdLib
251+ else do buildStdLib
203− buildRTS
252+ buildRTS
205 verbosity = S.fromFlag $ S.buildVerbosity flags
254 verbosity = S.fromFlag $ S.buildVerbosity flags
@@ -210,35 +259,54 @@ idrisBuild _ flags _ local = unless (execOnly (configFlags local)) $ do
211 makeBuild dir = make verbosity [ "-C", dir, "build" , "IDRIS=" ++ idrisCmd local]
260 makeBuild dir = make verbosity [ "-C", dir, "build" , "IDRIS=" ++ idrisCmd local]
213− buildRTS = make verbosity (["-C", "rts", "build"] ++
262+ buildRTS = make verbosity (["-C", "rts", "build"] ++
214 gmpflag (usesGMP (configFlags local)))
263 gmpflag (usesGMP (configFlags local)))
216 gmpflag False = []
265 gmpflag False = []
217 gmpflag True = ["GMP=-DIDRIS_GMP"]
266 gmpflag True = ["GMP=-DIDRIS_GMP"]
221-- -----------------------------------------------------------------------------
268-- -----------------------------------------------------------------------------
222-- Copy/Install
269-- Copy/Install
224−idrisInstall verbosity copy pkg local = unless (execOnly (configFlags local)) $ do
271+idrisInstall verbosity copy pkg local
272+ = if (execOnly (configFlags local)) then installRTS
225− installStdLib
273+ else do installStdLib
226− installRTS
274+ installRTS
228 target = datadir $ L.absoluteInstallDirs pkg local copy
277 target = datadir $ L.absoluteInstallDirs pkg local copy
230 installStdLib = do
279 installStdLib = do
280+ let target' = target -- </> "libs"
231− putStrLn $ "Installing libraries in " ++ target
281+ putStrLn $ "Installing libraries in " ++ target'
232− makeInstall "libs" target
282+ makeInstall "libs" target'
234 installRTS = do
284 installRTS = do
235 let target' = target </> "rts"
285 let target' = target </> "rts"
236 putStrLn $ "Installing run time system in " ++ target'
286 putStrLn $ "Installing run time system in " ++ target'
237 makeInstall "rts" target'
287 makeInstall "rts" target'
290+ let mandest = mandir (L.absoluteInstallDirs pkg local copy) ++ "/man1"
291+ notice verbosity $ unwords ["Copying man page to", mandest]
292+ installOrdinaryFiles verbosity mandest [("man", "idris.1")]
239 makeInstall src target =
294 makeInstall src target =
240 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
242-- -----------------------------------------------------------------------------
310-- -----------------------------------------------------------------------------
@@ -247,6 +315,7 @@ idrisInstall verbosity copy pkg local = unless (execOnly (configFlags local)) $
247main = defaultMainWithHooks $ simpleUserHooks
315main = defaultMainWithHooks $ simpleUserHooks
248 { postClean = idrisClean
316 { postClean = idrisClean
249 , postConf = idrisConfigure
317 , postConf = idrisConfigure
318+ , preBuild = idrisPreBuild
250 , postBuild = idrisBuild
319 , postBuild = idrisBuild
251 , postCopy = \_ flags pkg local ->
320 , postCopy = \_ flags pkg local ->
252 idrisInstall (S.fromFlag $ S.copyVerbosity flags)
321 idrisInstall (S.fromFlag $ S.copyVerbosity flags)
@@ -254,6 +323,5 @@ main = defaultMainWithHooks $ simpleUserHooks
254 , postInst = \_ flags pkg local ->
323 , postInst = \_ flags pkg local ->
255 idrisInstall (S.fromFlag $ S.installVerbosity flags)
324 idrisInstall (S.fromFlag $ S.installVerbosity flags)
256 NoCopyDest pkg local
325 NoCopyDest pkg local
257− , preSDist = idrisPreSDist --do { putStrLn (show args) ; putStrLn (show flags) ; return emptyHookedBuildInfo }
326+ , testHook = idrisTestHook
258− , 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'
@@ -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.idr+20−16
@@ -1,20 +1,28 @@
3import System
3import System
6alu : String
5alu : String
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.
7alu = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\
12alu = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\
8 \TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\
13 \TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\
9 \CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC\
14 \CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC\
10 \GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
15 \GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
12−iub : List (Char, Float)
20+iub : List (Char, Double)
13iub = [('a',0.27),('c',0.12),('g',0.12),('t',0.27),('B',0.02)
21iub = [('a',0.27),('c',0.12),('g',0.12),('t',0.27),('B',0.02)
14 ,('D',0.02),('H',0.02),('K',0.02),('M',0.02),('N',0.02)
22 ,('D',0.02),('H',0.02),('K',0.02),('M',0.02),('N',0.02)
15 ,('R',0.02),('S',0.02),('V',0.02),('W',0.02),('Y',0.02)]
23 ,('R',0.02),('S',0.02),('V',0.02),('W',0.02),('Y',0.02)]
17−homosapiens : List (Char, Float)
25+homosapiens : List (Char, Double)
18homosapiens = [('a',0.3029549426680),('c',0.1979883004921)
26homosapiens = [('a',0.3029549426680),('c',0.1979883004921)
19 ,('g',0.1975473066391),('t',0.3015094502008)]
27 ,('g',0.1975473066391),('t',0.3015094502008)]
@@ -30,24 +38,20 @@ splitAt' : Nat -> String -> (String, String)
30splitAt' n s = let s' = unpack s in (pack $ take n s', pack $ drop n s')
38splitAt' n s = let s' = unpack s in (pack $ take n s', pack $ drop n s')
32writeAlu : String -> String -> IO ()
40writeAlu : String -> String -> IO ()
33−writeAlu name s0 = putStrLn name $> go s0
41+writeAlu name s0 = putStrLn name *> go s0
35− go "" = return ()
43+ go "" = pure ()
36− go s = let (h,t) = splitAt' 60 s in putStrLn h $> go t
44+ go s = let (h,t) = splitAt' 60 s in putStrLn h *> go t
38replicate : Int -> Char -> String
46replicate : Int -> Char -> String
39replicate 0 c = ""
47replicate 0 c = ""
40replicate n c = singleton c <+> replicate (n-1) c
48replicate n c = singleton c <+> replicate (n-1) c
42−scanl : (f : acc -> a -> acc) -> acc -> List a -> List acc
43−scanl f q ls = q :: (case ls of
45− x::xs => scanl f (f q x) xs)
47−accum : (Char,Float) -> (Char,Float) -> (Char,Float)
51+accum : (Char,Double) -> (Char,Double) -> (Char,Double)
48accum (_,p) (c,q) = (c,p+q)
52accum (_,p) (c,q) = (c,p+q)
50−make : String -> Int -> List (Char, Float) -> Int -> IO Int
54+make : String -> Int -> List (Char, Double) -> Int -> IO Int
51make name n0 tbl seed0 = do
55make name n0 tbl seed0 = do
52 putStrLn name
56 putStrLn name
53 make' n0 0 seed0 ""
57 make' n0 0 seed0 ""
@@ -55,7 +59,7 @@ make name n0 tbl seed0 = do
55 modulus : Int
59 modulus : Int
56 modulus = 139968
60 modulus = 139968
58− fill : List (Char,Float) -> Int -> List String
62+ fill : List (Char,Double) -> Int -> List String
59 fill ((c,p) :: cps) j =
63 fill ((c,p) :: cps) j =
60 let k = min modulus (cast (cast modulus * p + 1))
64 let k = min modulus (cast (cast modulus * p + 1))
61 in replicate (k - j) c :: fill cps k
65 in replicate (k - j) c :: fill cps k
@@ -65,13 +69,13 @@ make name n0 tbl seed0 = do
65 lookupTable = Foldable.concat (fill (scanl accum ('a',0) tbl) 0)
69 lookupTable = Foldable.concat (fill (scanl accum ('a',0) tbl) 0)
67 make' : Int -> Int -> Int -> String -> IO Int
71 make' : Int -> Int -> Int -> String -> IO Int
68− make' 0 col seed buf = when (col > 0) (putStrLn buf) $> return seed
72+ make' 0 col seed buf = when (col > 0) (putStrLn buf) *> pure seed
69 make' n col seed buf = do
73 make' n col seed buf = do
70 let newseed = modInt (seed * 3877 + 29573) modulus
74 let newseed = modInt (seed * 3877 + 29573) modulus
71 let nextchar = strIndex lookupTable newseed
75 let nextchar = strIndex lookupTable newseed
72 let newbuf = buf <+> singleton nextchar
76 let newbuf = buf <+> singleton nextchar
73 if col+1 >= 60
77 if col+1 >= 60
74− then putStrLn newbuf $> make' (n-1) 0 newseed ""
78+ then putStrLn newbuf *> make' (n-1) 0 newseed ""
75 else make' (n-1) (col+1) newseed newbuf
79 else make' (n-1) (col+1) newseed newbuf
@@ -81,4 +85,4 @@ main = do
81 writeAlu ">ONE Homo sapiens alu" (takeRepeat (fromInteger (cast n)*2) alu)
85 writeAlu ">ONE Homo sapiens alu" (takeRepeat (fromInteger (cast n)*2) alu)
82 nseed <- make ">TWO IUB ambiguity codes" (fromInteger (cast n)*3) iub 42
86 nseed <- make ">TWO IUB ambiguity codes" (fromInteger (cast n)*3) iub 42
83 make ">THREE Homo sapiens frequency" (fromInteger (cast n)*5) homosapiens nseed
87 make ">THREE Homo sapiens frequency" (fromInteger (cast n)*5) homosapiens nseed
benchmarks/pidigits/pidigits.idr+11−11
@@ -1,18 +1,19 @@
1import System
1import System
3{- Toy program that outputs the n first digits of Pi.
4{- Toy program that outputs the n first digits of Pi.
5− Inspired from http://www.haskell.org/haskellwiki/Shootout/Pidigits.
6+ Inspired from https://www.haskell.org/haskellwiki/Shootout/Pidigits.
6 The original ns and str lazy lists have been replaced by strict functions.
7 The original ns and str lazy lists have been replaced by strict functions.
8− Memory usage seems to be excessive. One of the branches of str is tail recursive, and
9+ Memory usage seems to be excessive. One of the branches of str is tail recursive, and
9 the other one only needs to cons an extra Integer.
10 the other one only needs to cons an extra Integer.
11− For reference, the Haskell version runs in 0m0.230s when printing to /dev/null.
12+ For reference, the Haskell version runs in 0m0.230s when printing to /dev/null.
12 It almost runs in constant space.
13 It almost runs in constant space.
15−data F = mkF Integer Integer Integer
16+data F = MkF Integer Integer Integer
17-- Prints the list of digits by groups of 10
18-- Prints the list of digits by groups of 10
18loop : Nat -> Nat -> List Integer -> IO()
19loop : Nat -> Nat -> List Integer -> IO()
@@ -23,19 +24,19 @@ loop (S k) k' (x::xs) = do putStr (show x)
23 loop k (S k') xs
24 loop k (S k') xs
25fn : Integer -> F
26fn : Integer -> F
26−fn k = mkF k (4*k+2) (2*k+1)
27+fn k = MkF k (4*k+2) (2*k+1)
28flr : Integer -> F -> Integer
29flr : Integer -> F -> Integer
29−flr x (mkF q r t) = (q*x + r) `div` t
30+flr x (MkF q r t) = (q*x + r) `div` t
31comp : F -> F -> F
32comp : F -> F -> F
32−comp (mkF q r t) (mkF u v x) = mkF (q*u) (q*v+r*x) (t*x)
33+comp (MkF q r t) (MkF u v x) = MkF (q*u) (q*v+r*x) (t*x)
34-- Returns the list of digits of pi. Memory hungry.
35-- Returns the list of digits of pi. Memory hungry.
35str : F -> Integer -> Nat -> List Integer
36str : F -> Integer -> Nat -> List Integer
36str _ _ Z = Nil
37str _ _ Z = Nil
37str z k (S n) = if(y == flr 4 z)
38str z k (S n) = if(y == flr 4 z)
38− then y :: str (comp (mkF 10 (-10*y) 1) z ) k n
39+ then y :: str (comp (MkF 10 (-10*y) 1) z ) k n
39 else str (comp z (fn k)) (k+1) (S n)
40 else str (comp z (fn k)) (k+1) (S n)
40 where y = flr 3 z
41 where y = flr 3 z
@@ -43,10 +44,9 @@ pidigit : IO()
43pidigit = do
44pidigit = do
44 [_,a] <- getArgs
45 [_,a] <- getArgs
45 let n = fromIntegerNat (the Integer (cast a))
46 let n = fromIntegerNat (the Integer (cast a))
46− let l = str (mkF 1 0 1) 1 n
47+ let l = str (MkF 1 0 1) 1 n
47 loop 10 0 l
48 loop 10 0 l
50main : IO ()
51main : IO ()
51main = pidigit
52main = pidigit
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− printLn 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− printLn solved
26+ printLn solved
24 [self] => putStrLn ("Usage: " ++ self ++ " <board file>")
27 [self] => putStrLn ("Usage: " ++ self ++ " <board file>")
benchmarks/quasigroups/Parser.idr+12−9
@@ -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,7 +45,7 @@ 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)
@@ -61,9 +64,9 @@ 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
@@ -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+6−6
@@ -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,7 +33,7 @@ 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
@@ -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)
@@ -182,9 +184,8 @@ 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
@@ -192,9 +193,8 @@ fillBoard {n=(S n)} b l with (emptyCell b)
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'
benchmarks/trivial/sortvec.idr+6−5
@@ -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,13 +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 printLn (vsort vec)
25 printLn (vsort vec)
codegen/idris-c/Main.hs → codegen/idris-codegen-c/Main.hsrenamed+12−15
@@ -1,26 +1,26 @@
1module Main where
1module Main where
4import Idris.AbsSyntax
3import Idris.AbsSyntax
5import Idris.ElabDecls
4import Idris.ElabDecls
6−import Idris.REPL
5+import Idris.Main
9import IRTS.CodegenC
7import IRTS.CodegenC
11import System.Environment
13import System.Environment
12import System.Exit
14import System.Exit
19data Opts = Opts { inputs :: [FilePath],
18data Opts = Opts { inputs :: [FilePath],
20 interface :: Bool,
19 interface :: Bool,
21 output :: FilePath }
20 output :: FilePath }
22+showUsage = do putStrLn "A code generator which is intended to be called by the compiler, not by a user."
23−showUsage = do putStrLn "Usage: idris-c <ibc-files> [-o <output-file>]"
23+ putStrLn "Usage: idris-codegen-c <ibc-files> [-o <output-file>]"
24 exitWith ExitSuccess
24 exitWith ExitSuccess
26getOpts :: IO Opts
26getOpts :: IO Opts
@@ -36,17 +36,14 @@ c_main :: Opts -> Idris ()
36c_main opts = do runIO setupBundledCC
36c_main opts = do runIO setupBundledCC
38 loadInputs (inputs opts) Nothing
38 loadInputs (inputs opts) Nothing
39− mainProg <- if interface opts
39+ mainProg <- if interface opts
40 then liftM Just elabMain
40 then liftM Just elabMain
41 else return Nothing
41 else return Nothing
42− ir <- compile (Via "c") (output opts) mainProg
42+ ir <- compile (Via IBCFormat "c") (output opts) mainProg
43 runIO $ codegenC ir
43 runIO $ codegenC ir
45main :: IO ()
45main :: IO ()
46main = do opts <- getOpts
46main = do opts <- getOpts
47− if (null (inputs opts))
47+ if (null (inputs opts))
48 then showUsage
48 then showUsage
49− else runMain (c_main opts)
49+ else runMain (c_main opts)
codegen/idris-javascript/Main.hs → codegen/idris-codegen-javascript/Main.hsrenamed+8−8
@@ -1,23 +1,23 @@
1module Main where
1module Main where
4import Idris.AbsSyntax
3import Idris.AbsSyntax
5import Idris.ElabDecls
4import Idris.ElabDecls
6−import Idris.REPL
5+import Idris.Main
9import IRTS.CodegenJavaScript
7import IRTS.CodegenJavaScript
11import System.Environment
10import System.Environment
12import System.Exit
11import System.Exit
16−data Opts = Opts { inputs :: [FilePath]
15+ inputs :: [FilePath]
17 , output :: FilePath
16 , output :: FilePath
19+showUsage = do putStrLn "A code generator which is intended to be called by the compiler, not by a user."
20−showUsage = do putStrLn "Usage: idris-javascript <ibc-files> [-o <output-file>]"
20+ putStrLn "Usage: idris-codegen-javascript <ibc-files> [-o <output-file>]"
21 exitWith ExitSuccess
21 exitWith ExitSuccess
23getOpts :: IO Opts
23getOpts :: IO Opts
@@ -32,7 +32,7 @@ jsMain :: Opts -> Idris ()
32jsMain opts = do elabPrims
32jsMain opts = do elabPrims
33 loadInputs (inputs opts) Nothing
33 loadInputs (inputs opts) Nothing
34 mainProg <- elabMain
34 mainProg <- elabMain
35− ir <- compile (Via "javascript") (output opts) (Just mainProg)
35+ ir <- compile (Via IBCFormat "javascript") (output opts) (Just mainProg)
36 runIO $ codegenJavaScript ir
36 runIO $ codegenJavaScript ir
38main :: IO ()
38main :: IO ()
codegen/idris-node/Main.hs → codegen/idris-codegen-node/Main.hsrenamed+17−11
@@ -1,42 +1,48 @@
1module Main where
1module Main where
4import Idris.AbsSyntax
3import Idris.AbsSyntax
5import Idris.ElabDecls
4import Idris.ElabDecls
6−import Idris.REPL
5+import Idris.Main
9import IRTS.CodegenJavaScript
7import IRTS.CodegenJavaScript
11import System.Environment
14import System.Environment
12import System.Exit
15import System.Exit
16data Opts = Opts { inputs :: [FilePath]
17data Opts = Opts { inputs :: [FilePath]
17 , output :: FilePath
19 , output :: FilePath
22+showUsage = do putStrLn "A code generator which is intended to be called by the compiler, not by a user."
20−showUsage = do putStrLn "Usage: idris-node <ibc-files> [-o <output-file>]"
23+ putStrLn "Usage: idris-codegen-node <ibc-files> [-o <output-file>]"
21 exitWith ExitSuccess
24 exitWith ExitSuccess
23getOpts :: IO Opts
26getOpts :: IO Opts
24getOpts = do xs <- getArgs
27getOpts = do xs <- getArgs
25− return $ process (Opts [] "main.js") xs
28+ return $ process (Opts [] False "main.js") xs
27 process opts ("-o":o:xs) = process (opts { output = o }) xs
30 process opts ("-o":o:xs) = process (opts { output = o }) xs
31+ process opts ("--interface":xs) = process (opts { interface = True }) xs
28 process opts (x:xs) = process (opts { inputs = x:inputs opts }) xs
32 process opts (x:xs) = process (opts { inputs = x:inputs opts }) xs
29 process opts [] = opts
33 process opts [] = opts
31jsMain :: Opts -> Idris ()
35jsMain :: Opts -> Idris ()
32jsMain opts = do elabPrims
36jsMain opts = do elabPrims
33 loadInputs (inputs opts) Nothing
37 loadInputs (inputs opts) Nothing
38+ mainProg <- if interface opts
34− mainProg <- elabMain
40+ else liftM Just elabMain
35− ir <- compile (Via "node") (output opts) (Just mainProg)
41+ ir <- compile (Via IBCFormat "node") (output opts) mainProg
36 runIO $ codegenNode ir
42 runIO $ codegenNode ir
38main :: IO ()
44main :: IO ()
39main = do opts <- getOpts
45main = do opts <- getOpts
40 if (null (inputs opts))
46 if (null (inputs opts))
41 then showUsage
47 then showUsage
42− else runMain (jsMain opts)
48+ else runMain (jsMain opts)
@@ -1,12 +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# IDRIS_ENABLE_STATS should not be set in final release
15# IDRIS_ENABLE_STATS should not be set in final release
4# Any flags defined here which alter the RTS API must also be added to src/IRTS/CodegenC.hs
16# Any flags defined here which alter the RTS API must also be added to src/IRTS/CodegenC.hs
5−CFLAGS :=-O2 -Wall -DHAS_PTHREAD -DIDRIS_ENABLE_STATS -msse2 $(CFLAGS)
17+CFLAGS :=-O2 -Wall -std=c99 -pipe -fdata-sections -ffunction-sections -D_POSIX_C_SOURCE=200809L -DHAS_PTHREAD -DIDRIS_ENABLE_STATS $(CFLAGS)
7−#CABALFLAGS :=
19+# CABALFLAGS :=
20+CABALFLAGS += --enable-tests
8## Disable building of Effects
21## Disable building of Effects
9−#CABALFLAGS :=-f NoEffects
22+#CABALFLAGS :=-f NoEffects $(CABALFLAGS)
11ifneq (, $(findstring bsd, $(MACHINE)))
25ifneq (, $(findstring bsd, $(MACHINE)))
12 GMP_INCLUDE_DIR :=
26 GMP_INCLUDE_DIR :=
@@ -17,24 +31,20 @@ endif
17MACHINE := $(shell $(CC) -dumpmachine)
31MACHINE := $(shell $(CC) -dumpmachine)
18ifneq (, $(findstring darwin, $(MACHINE)))
32ifneq (, $(findstring darwin, $(MACHINE)))
19 OS :=darwin
33 OS :=darwin
21−ifneq (, $(findstring cygwin, $(MACHINE)))
34+else ifneq (, $(findstring cygwin, $(MACHINE)))
22 OS :=windows
35 OS :=windows
24−ifneq (, $(findstring mingw, $(MACHINE)))
36+else ifneq (, $(findstring mingw, $(MACHINE)))
38+else ifneq (, $(findstring windows, $(MACHINE)))
25 OS :=windows
39 OS :=windows
32ifeq ($(OS),darwin)
44ifeq ($(OS),darwin)
33 SHLIB_SUFFIX :=.dylib
45 SHLIB_SUFFIX :=.dylib
35−ifeq ($(OS),windows)
46+else ifeq ($(OS),windows)
36 SHLIB_SUFFIX :=.DLL
47 SHLIB_SUFFIX :=.DLL
38 SHLIB_SUFFIX :=.so
49 SHLIB_SUFFIX :=.so
@@ -1 +1 @@
1−CABALFLAGS += -f LLVM -f FFI -f curses --disable-documentation --disable-profiling --disable-library-profiling
1+CABALFLAGS += -f GMP -f FFI --disable-documentation --disable-profiling --disable-library-profiling
@@ -7,4 +7,4 @@ rights to Documentation for Idris.
8More information concerning the CC0 can be found online at:
8More information concerning the CC0 can be found online at:
10− http://creativecommons.org/publicdomain/zero/1.0/
10+ https://creativecommons.org/publicdomain/zero/1.0/
@@ -9,7 +9,7 @@ BUILDDIR = _build
10# User-friendly check for sphinx-build
10# User-friendly check for sphinx-build
11ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
11ifeq ($(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 http://sphinx-doc.org/)
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/)
15# Internal variables.
15# Internal variables.
@@ -1,7 +1,7 @@
1# Documentation for the Idris Language.
1# Documentation for the Idris Language.
4−This manual has been prepared using ReStructured Text and the [Sphinx Documentation Generator](http://sphinx-doc.org) for future inclusion on [Read The Docs](http://www.readthedocs.org).
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).
6## Dependencies
6## Dependencies
@@ -12,7 +12,7 @@ To build the manual the following dependencies must be met. We assume that you h
12Python should be installed by default on most systems.
12Python should be installed by default on most systems.
13Sphinx can be installed either through your hosts package manager or using pip/easy_install.
13Sphinx can be installed either through your hosts package manager or using pip/easy_install.
15−*Note* [ReadTheDocs](http://www.readthedocs.org) works with Sphinx
15+*Note* [ReadTheDocs](https://www.readthedocs.org) works with Sphinx
16 `v1.2.2`. If you install a more recent version of sphinx then
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
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
18 of readthedocs and be ignored. In the past we had several code-blocks
@@ -45,7 +45,7 @@ rights to Documentation for Idris.
46More information concerning the CC0 can be found online at:
46More information concerning the CC0 can be found online at:
48− http://creativecommons.org/publicdomain/zero/1.0/
48+ https://creativecommons.org/publicdomain/zero/1.0/
51When contributing material to the manual please bear in mind that the work will be licensed as above.
51When 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;
@@ -33,7 +33,7 @@ on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
34extensions = [
34extensions = [
35 'sphinx.ext.todo',
35 'sphinx.ext.todo',
36− 'sphinx.ext.pngmath',
36+# 'sphinx.ext.pngmath', # imgmath is not supported on readthedocs.
37 'sphinx.ext.ifconfig',
37 'sphinx.ext.ifconfig',
@@ -51,7 +51,7 @@ master_doc = 'index'
52# General information about the project.
52# General information about the project.
53project = u'Idris'
53project = u'Idris'
54−copyright = u'2015, The Idris Community'
54+copyright = u'2017-2020, The Idris Community'
55author = u'The Idris Community'
55author = u'The Idris Community'
57# The version info for the project you're documenting, acts as replacement for
57# The version info for the project you're documenting, acts as replacement for
@@ -59,9 +59,9 @@ author = u'The Idris Community'
59# built documents.
59# built documents.
61# The short X.Y version.
61# The short X.Y version.
62−version = '0.9.17'
62+version = '1.3'
63# The full version, including alpha/beta/rc tags.
63# The full version, including alpha/beta/rc tags.
64−release = '0.9.17'
64+release = '1.3.2'
66# The language for content autogenerated by Sphinx. Refer to documentation
66# The language for content autogenerated by Sphinx. Refer to documentation
67# for a list of supported languages.
67# for a list of supported languages.
@@ -151,6 +151,12 @@ if not on_rtd: # only import and set the theme if we're building docs locally
151# so a file named "default.css" will overwrite the builtin "default.css".
151# so a file named "default.css" will overwrite the builtin "default.css".
152html_static_path = ['_static']
152html_static_path = ['_static']
156+ '_static/theme_overrides.css', # override wide tables in RTD theme
154# Add any extra paths that contain custom files (such as robots.txt or
160# Add any extra paths that contain custom files (such as robots.txt or
155# .htaccess) here, relative to this directory. These files are copied
161# .htaccess) here, relative to this directory. These files are copied
156# directly to the root of the documentation.
162# directly to the root of the documentation.
@@ -216,16 +222,77 @@ htmlhelp_basename = 'IdrisManualdoc'
217# -- Options for LaTeX output ---------------------------------------------
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}
219latex_elements = {
239latex_elements = {
220# The paper size ('letterpaper' or 'a4paper').
240# The paper size ('letterpaper' or 'a4paper').
221'papersize': 'a4paper',
241'papersize': 'a4paper',
246+'releasename': 'Version',
223# The font size ('10pt', '11pt' or '12pt').
248# The font size ('10pt', '11pt' or '12pt').
224'pointsize': '10pt',
249'pointsize': '10pt',
226# Additional stuff for the LaTeX preamble.
251# Additional stuff for the LaTeX preamble.
227−#'preamble': '',
252+'preamble': r'''
228−
253+\usepackage{lmodern}
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"
229# Latex figure (float) alignment
296# Latex figure (float) alignment
230#'figure_align': 'htbp',
297#'figure_align': 'htbp',
@@ -234,15 +301,17 @@ latex_elements = {
234# (source start file, target name, title,
301# (source start file, target name, title,
235# author, documentclass [howto, manual, or own class]).
302# author, documentclass [howto, manual, or own class]).
236latex_documents = [
303latex_documents = [
237− ('guides/index', 'idris-guides.tex', u'Idris Tutorial Series', u'The Idris Community', 'manual'),
304+ # (master_doc, 'idris.tex', u'Documentation for the Idris Language', u'The Idris Community', 'report')
238− ('reference/index', 'idris-reference.tex', u'The Idris Reference', u'The Idris Community', 'manual'),
239− ('tutorial/index', 'idris-tutorial.tex', u'The Idris Tutorial', u'The Idris Community', 'manual'),
305+ ('tutorial/index', 'idris-tutorial.tex', u'The Idris Tutorial', u'The Idris Community', 'howto'),
240− ('effects/index', 'eff-tutorial.tex', u'The Effects Tutorial', u'The Idris Community', 'manual')
309+latex_show_pagerefs = True
310+latex_show_url = 'footnote'
243# The name of an image file (relative to this directory) to place at the top of
312# The name of an image file (relative to this directory) to place at the top of
244# the title page.
313# the title page.
245−#latex_logo = None
314+latex_logo = '../icons/idris-512x512.png'
247# For "manual" documents, if this is true, then toplevel headings are parts,
316# For "manual" documents, if this is true, then toplevel headings are parts,
248# not chapters.
317# not chapters.
docs/effects/conclusions.rst+11−11
@@ -13,21 +13,21 @@ paper [1]_.
13Some libraries and programs which use ``Effects`` can be found in the
13Some libraries and programs which use ``Effects`` can be found in the
14following places:
14following places:
16−- http://github.com/edwinb/SDL-idris — some bindings for the SDL media
16+- https://github.com/edwinb/SDL-idris — some bindings for the SDL media
17 library, supporting graphics in particular.
17 library, supporting graphics in particular.
19−- http://github.com/edwinb/idris-demos — various demonstration
19+- https://github.com/edwinb/idris-demos — various demonstration
20 programs, including several examples from this tutorial, and a “Space
20 programs, including several examples from this tutorial, and a “Space
21 Invaders” game.
21 Invaders” game.
23- https://github.com/SimonJF/IdrisNet2 — networking and socket
23- https://github.com/SimonJF/IdrisNet2 — networking and socket
24 libraries.
24 libraries.
26−- http://github.com/edwinb/Protocols — a high level communication
26+- https://github.com/edwinb/Protocols — a high level communication
27 protocol description language.
27 protocol description language.
29The inspiration for the ``Effects`` library was Bauer and Pretnar’s
29The inspiration for the ``Effects`` library was Bauer and Pretnar’s
30−Eff language [2]_, which describes a langauge based on algebraic
30+Eff language [2]_, which describes a language based on algebraic
31effects and handlers. Other recent languages and libraries have also
31effects and handlers. Other recent languages and libraries have also
32been built on this ideas, for example [3]_ and [4]_. The theoretical
32been built on this ideas, for example [3]_ and [4]_. The theoretical
33foundations are also well-studied see [5]_, [6]_, [7]_, [8]_.
33foundations are also well-studied see [5]_, [6]_, [7]_, [8]_.
@@ -37,32 +37,32 @@ foundations are also well-studied see [5]_, [6]_, [7]_, [8]_.
37.. [1] Edwin Brady. 2013. Programming and reasoning with algebraic
37.. [1] Edwin Brady. 2013. Programming and reasoning with algebraic
38 effects and dependent types. SIGPLAN Not. 48, 9 (September
38 effects and dependent types. SIGPLAN Not. 48, 9 (September
39 2013), 133-144. DOI=10.1145/2544174.2500581
39 2013), 133-144. DOI=10.1145/2544174.2500581
40− http://doi.acm.org/10.1145/2544174.2500581
40+ https://dl.acm.org/citation.cfm?doid=2544174.2500581
42.. [2] Andrej Bauer, Matija Pretnar, Programming with algebraic
42.. [2] Andrej Bauer, Matija Pretnar, Programming with algebraic
43 effects and handlers, Journal of Logical and Algebraic Methods
43 effects and handlers, Journal of Logical and Algebraic Methods
44 in Programming, Volume 84, Issue 1, January 2015, Pages
44 in Programming, Volume 84, Issue 1, January 2015, Pages
45 108-123, ISSN 2352-2208,
45 108-123, ISSN 2352-2208,
46− http://dx.doi.org/10.1016/j.jlamp.2014.02.001.
46+ http://math.andrej.com/wp-content/uploads/2012/03/eff.pdf
47− (http://www.sciencedirect.com/science/article/pii/S2352220814000194)
47+
49.. [3] Ben Lippmeier. 2009. Witnessing Purity, Constancy and
49.. [3] Ben Lippmeier. 2009. Witnessing Purity, Constancy and
50 Mutability. In Proceedings of the 7th Asian Symposium on
50 Mutability. In Proceedings of the 7th Asian Symposium on
51 Programming Languages and Systems (APLAS '09), Zhenjiang Hu
51 Programming Languages and Systems (APLAS '09), Zhenjiang Hu
52 (Ed.). Springer-Verlag, Berlin, Heidelberg,
52 (Ed.). Springer-Verlag, Berlin, Heidelberg,
53 95-110. DOI=10.1007/978-3-642-10672-9_9
53 95-110. DOI=10.1007/978-3-642-10672-9_9
54− http://dx.doi.org/10.1007/978-3-642-10672-9_9
54+ https://link.springer.com/chapter/10.1007%2F978-3-642-10672-9_9
56.. [4] Ohad Kammar, Sam Lindley, and Nicolas Oury. 2013. Handlers in
57.. [4] Ohad Kammar, Sam Lindley, and Nicolas Oury. 2013. Handlers in
57 action. SIGPLAN Not. 48, 9 (September 2013),
58 action. SIGPLAN Not. 48, 9 (September 2013),
58 145-158. DOI=10.1145/2544174.2500590
59 145-158. DOI=10.1145/2544174.2500590
59− http://doi.acm.org/10.1145/2544174.2500590
60+ https://dl.acm.org/citation.cfm?doid=2544174.2500590
61.. [5] Martin Hyland, Gordon Plotkin, John Power, Combining effects:
62.. [5] Martin Hyland, Gordon Plotkin, John Power, Combining effects:
62 Sum and tensor, Theoretical Computer Science, Volume 357,
63 Sum and tensor, Theoretical Computer Science, Volume 357,
63 Issues 1–3, 25 July 2006, Pages 70-99, ISSN 0304-3975,
64 Issues 1–3, 25 July 2006, Pages 70-99, ISSN 0304-3975,
64− http://dx.doi.org/10.1016/j.tcs.2006.03.013.
65− (http://www.sciencedirect.com/science/article/pii/S0304397506002659)
65+ (https://www.sciencedirect.com/science/article/pii/S0304397506002659)
67.. [6] Paul Blain Levy. 2004. Call-By-Push-Value: A
67.. [6] Paul Blain Levy. 2004. Call-By-Push-Value: A
68 Functional/Imperative Synthesis (Semantics Structures in
68 Functional/Imperative Synthesis (Semantics Structures in
docs/effects/depeff.rst+60−46
@@ -24,7 +24,7 @@ It might look something like the following:
25.. code-block:: idris
25.. code-block:: idris
27− readInt : { [STATE (List Int), STDIO] } Eff ()
27+ readInt : Eff () [STATE (List Int), STDIO]
28 readInt = do let x = trim !getStr
28 readInt = do let x = trim !getStr
29 put (cast x :: !get)
29 put (cast x :: !get)
@@ -33,7 +33,7 @@ But what if, instead of a list of integers, we would like to store a
34.. code-block:: idris
34.. code-block:: idris
36− readInt : { [STATE (Vect n Int), STDIO] } Eff ()
36+ readInt : Eff () [STATE (Vect n Int), STDIO]
37 readInt = do let x = trim !getStr
37 readInt = do let x = trim !getStr
38 put (cast x :: !get)
38 put (cast x :: !get)
@@ -43,12 +43,12 @@ express this as follows:
44.. code-block:: idris
44.. code-block:: idris
46− readInt : { [STATE (Vect n Int), STDIO] ==>
46+ readInt : Eff () [STATE (Vect n Int), STDIO]
47− [STATE (Vect (S n) Int), STDIO] } Eff ()
47+ [STATE (Vect (S n) Int), STDIO]
48 readInt = do let x = trim !getStr
48 readInt = do let x = trim !getStr
49 putM (cast x :: !get)
49 putM (cast x :: !get)
51−The notation ``{ xs ==> xs’ } Eff a`` in a type means that the operation
51+The type ``Eff a xs xs'`` means that the operation
52begins with effects ``xs`` available, and ends with effects ``xs’``
52begins with effects ``xs`` available, and ends with effects ``xs’``
53available. We have used ``putM`` to update the state, where the ``M``
53available. We have used ``putM`` to update the state, where the ``M``
54suffix indicates that the *type* is being updated as well as the value.
54suffix indicates that the *type* is being updated as well as the value.
@@ -56,7 +56,7 @@ It has the following type:
57.. code-block:: idris
57.. code-block:: idris
59− putM : y -> { [STATE x] ==> [STATE y] } Eff ()
59+ putM : y -> Eff () [STATE x] [STATE y]
61Result-dependent Effects
61Result-dependent Effects
62========================
62========================
@@ -69,8 +69,8 @@ digits). As a first attempt, we could try the following, returning a
70.. code-block:: idris
70.. code-block:: idris
72− readInt : { [STATE (Vect n Int), STDIO] ==>
72+ readInt : Eff Bool [STATE (Vect n Int), STDIO]
73− [STATE (Vect (S n) Int), STDIO] } Eff Bool
73+ [STATE (Vect (S n) Int), STDIO]
74 readInt = do let x = trim !getStr
74 readInt = do let x = trim !getStr
75 case all isDigit (unpack x) of
75 case all isDigit (unpack x) of
76 False => pure False
76 False => pure False
@@ -91,31 +91,31 @@ value read from the user was valid. We can express this in the type:
92.. code-block:: idris
92.. code-block:: idris
94− readInt : { [STATE (Vect n Int), STDIO] ==>
94+ readInt : Eff Bool [STATE (Vect n Int), STDIO]
95− {ok} if ok then [STATE (Vect (S n) Int), STDIO]
95+ (\ok => if ok then [STATE (Vect (S n) Int), STDIO]
96− else [STATE (Vect n Int), STDIO] } Eff Bool
96+ else [STATE (Vect n Int), STDIO])
97 readInt = do let x = trim !getStr
97 readInt = do let x = trim !getStr
98 case all isDigit (unpack x) of
98 case all isDigit (unpack x) of
99− False => pure False
99+ False => pureM False
100 True => do putM (cast x :: !get)
100 True => do putM (cast x :: !get)
101− pure True
101+ pureM True
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
103−The notation ``{ xs ==> res xs’ } Eff a`` in a type means that the
108+ pureM : (val : a) -> EffM m a (xs val) xs
104−effects available are updated from ``xs`` to ``xs’``, *and* the
105−resulting effects ``xs’`` may depend on the result of the operation
106−``res``, of type ``a``. Here, the resulting effects are computed from
107−the result ``ok``—if ``True``, the vector is extended, otherwise it
110−When using the function, we will naturally have to check its return
110+When using ``readInt``, we will have to check its return
111value in order to know what the new set of effects is. For example, to
111value in order to know what the new set of effects is. For example, to
112read a set number of values into a vector, we could write the following:
112read a set number of values into a vector, we could write the following:
114.. code-block:: idris
114.. code-block:: idris
116 readN : (n : Nat) ->
116 readN : (n : Nat) ->
117− { [STATE (Vect m Int), STDIO] ==>
117+ Eff () [STATE (Vect m Int), STDIO]
118− [STATE (Vect (n + m) Int), STDIO] } Eff ()
118+ [STATE (Vect (n + m) Int), STDIO]
119 readN Z = pure ()
119 readN Z = pure ()
120 readN {m} (S k) = case !readInt of
120 readN {m} (S k) = case !readInt of
121 True => rewrite plusSuccRightSucc k m in readN k
121 True => rewrite plusSuccRightSucc k m in readN k
@@ -153,12 +153,21 @@ file management follows a resource usage protocol with the following
154- When a file is closed, its handle should no longer be used
154- When a file is closed, its handle should no longer be used
156−These requirements can be expressed formally in , by creating a
156+These requirements can be expressed formally by creating a
157``FILE_IO`` effect parameterised over a file handle state, which is
157``FILE_IO`` effect parameterised over a file handle state, which is
158either empty, open for reading, or open for writing. The ``FILE_IO``
158either empty, open for reading, or open for writing. The ``FILE_IO``
159−effect’s definition is given below. Note that this
159+effect’s definition is given below.
160−effect is mainly for illustrative purposes—typically we would also like
162+ This effect is mainly for illustrative purposes.
163+ Typically we would also like to support random access files and
161−to support random access files and better reporting of error conditions.
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.
163.. code-block:: idris
172.. code-block:: idris
@@ -171,24 +180,30 @@ to support random access files and better reporting of error conditions.
172 data OpenFile : Mode -> Type
181 data OpenFile : Mode -> Type
174− open : String -> (m : Mode) ->
183+ open : (fname : String)
175− { [FILE_IO ()] ==>
184+ -> (m : Mode)
176− {ok} [FILE_IO (if ok then OpenFile m else ())] } Eff Bool
185+ -> Eff Bool [FILE_IO ()]
186+ (\res => [FILE_IO (case res of
177− close : { [FILE_IO (OpenFile m)] ==> [FILE_IO ()] } Eff ()
189+ close : Eff () [FILE_IO (OpenFile m)] [FILE_IO ()]
179− readLine : { [FILE_IO (OpenFile Read)] } Eff String
191+ readLine : Eff String [FILE_IO (OpenFile Read)]
180− writeLine : { [FILE_IO (OpenFile Write)] } Eff ()
192+ writeLine : String -> Eff () [FILE_IO (OpenFile Write)]
181− eof : { [FILE_IO (OpenFile Read)] } Eff Bool
193+ eof : Eff Bool [FILE_IO (OpenFile Read)]
183− instance Handler FileIO IO
195+ Handler FileIO IO where { ... }
185In particular, consider the type of ``open``:
197In particular, consider the type of ``open``:
187.. code-block:: idris
199.. code-block:: idris
189− open : String -> (m : Mode) ->
201+ open : (fname : String)
190− { [FILE_IO ()] ==>
202+ -> (m : Mode)
191− {ok} [FILE_IO (if ok then OpenFile m else ())] } Eff Bool
203+ -> Eff Bool [FILE_IO ()]
204+ (\res => [FILE_IO (case res of
193This returns a ``Bool`` which indicates whether opening the file was
208This returns a ``Bool`` which indicates whether opening the file was
194successful. The resulting state depends on whether the operation was
209successful. The resulting state depends on whether the operation was
@@ -199,10 +214,9 @@ we continue the protocol accordingly.
199.. _eff-readfile:
214.. _eff-readfile:
200.. code-block:: idris
215.. code-block:: idris
202− readFile : { [FILE_IO (OpenFile Read)] } Eff (List String)
217+ readFile : Eff (List String) [FILE_IO (OpenFile Read)]
203 readFile = readAcc [] where
218 readFile = readAcc [] where
204− readAcc : List String -> { [FILE_IO (OpenFile Read)] }
219+ readAcc : List String -> Eff (List String) [FILE_IO (OpenFile Read)]
206 readAcc acc = if (not !eof)
220 readAcc acc = if (not !eof)
207 then readAcc (!readLine :: acc)
221 then readAcc (!readLine :: acc)
208 else pure (reverse acc)
222 else pure (reverse acc)
@@ -214,7 +228,7 @@ correctly following the protocol:
215.. code-block:: idris
229.. code-block:: idris
217− dumpFile : String -> { [FILE_IO (), STDIO] } Eff ()
231+ dumpFile : String -> Eff () [FILE_IO (), STDIO]
218 dumpFile name = case !(open name Read) of
232 dumpFile name = case !(open name Read) of
219 True => do putStrLn (show !readFile)
233 True => do putStrLn (show !readFile)
@@ -255,7 +269,7 @@ Idris supports *pattern-matching* bindings, such as the following:
256.. code-block:: idris
270.. code-block:: idris
258− dumpFile : String -> { [FILE_IO (), STDIO] } Eff ()
272+ dumpFile : String -> Eff () [FILE_IO (), STDIO]
259 dumpFile name = do True <- open name Read
273 dumpFile name = do True <- open name Read
260 putStrLn (show !readFile)
274 putStrLn (show !readFile)
@@ -267,7 +281,7 @@ example, we could write:
268.. code-block:: idris
282.. code-block:: idris
270− dumpFile : String -> { [FILE_IO (), STDIO] } Eff ()
284+ dumpFile : String -> Eff () [FILE_IO (), STDIO]
271 dumpFile name = do True <- open name Read | False => putStrLn "Error"
285 dumpFile name = do True <- open name Read | False => putStrLn "Error"
272 putStrLn (show !readFile)
286 putStrLn (show !readFile)
@@ -297,7 +311,7 @@ reading command line arguments, among other things (see Appendix
298.. code-block:: idris
312.. code-block:: idris
300− getArgs : { [SYSTEM] } Eff (List String)
314+ getArgs : Eff (List String) [SYSTEM]
302A main program can read command line arguments as follows, where in the
316A main program can read command line arguments as follows, where in the
303list which is returned, the first element ``prog`` is the executable
317list which is returned, the first element ``prog`` is the executable
@@ -305,7 +319,7 @@ name and the second is an expected argument:
306.. code-block:: idris
320.. code-block:: idris
308− emain : { [SYSTEM, STDIO] } Eff ()
322+ emain : Eff () [SYSTEM, STDIO]
309 emain = do [prog, arg] <- getArgs
323 emain = do [prog, arg] <- getArgs
310 putStrLn $ "Argument is " ++ arg
324 putStrLn $ "Argument is " ++ arg
311 {- ... rest of function ... -}
325 {- ... rest of function ... -}
@@ -316,7 +330,7 @@ alternatives to give a better (more informative) error:
317.. code-block:: idris
331.. code-block:: idris
319− emain : { [SYSTEM, STDIO] } Eff ()
333+ emain : Eff () [SYSTEM, STDIO]
320 emain = do [prog, arg] <- getArgs | [] => putStrLn "Can't happen!"
334 emain = do [prog, arg] <- getArgs | [] => putStrLn "Can't happen!"
321 | [prog] => putStrLn "No arguments!"
335 | [prog] => putStrLn "No arguments!"
322 | _ => putStrLn "Too many arguments!"
336 | _ => putStrLn "Too many arguments!"
docs/effects/hangman.rst+31−35
@@ -95,7 +95,7 @@ NewWord
95 choice of 6 is somewhat arbitrary here) and the number of unique
95 choice of 6 is somewhat arbitrary here) and the number of unique
96 letters in the word still to be guessed.
96 letters in the word still to be guessed.
99 Get a string representation of the game state. This is for display
99 Get a string representation of the game state. This is for display
100 purposes; there are no pre- or postconditions.
100 purposes; there are no pre- or postconditions.
@@ -106,16 +106,18 @@ effect signature:
107 data MysteryRules : Effect where
107 data MysteryRules : Effect where
108 Guess : (x : Char) ->
108 Guess : (x : Char) ->
109+ sig MysteryRules Bool
109− { Mystery (Running (S g) (S w)) ==>
110+ (Mystery (Running (S g) (S w)))
111+ (\inword => if inword
110− {inword} if inword then Mystery (Running (S g) w)
112+ then Mystery (Running (S g) w)
111− else Mystery (Running g (S w)) }
113+ else Mystery (Running g (S w)))
112− MysteryRules Bool
114+ Won : sig MysteryRules () (Mystery (Running g 0))
113− Won : { Mystery (Running g 0) ==> Mystery NotRunning } MysteryRules ()
115+ (Mystery NotRunning)
116+ Lost : sig MysteryRules () (Mystery (Running 0 g))
114− Lost : { Mystery (Running 0 g) ==> Mystery NotRunning } MysteryRules ()
117+ (Mystery NotRunning)
115− NewWord : (w : String) ->
118+ NewWord : (w : String) ->
116− { Mystery NotRunning ==>
117− Mystery (Running 6 (length (letters w))) } MysteryRules ()
119+ sig MysteryRules () (Mystery NotRunning) (Mystery (Running 6 (length (letters w))))
118− StrState : { Mystery h } MysteryRules String
120+ Get : sig MysteryRules String (Mystery h)
120This description says nothing about how the rules are implemented. In
122This description says nothing about how the rules are implemented. In
121particular, it does not specify *how* to tell whether a guessed letter
123particular, it does not specify *how* to tell whether a guessed letter
@@ -191,11 +193,11 @@ implementation for ``MysteryRules`` is surprisingly straightforward:
192.. code-block:: idris
194.. code-block:: idris
194− instance Handler MysteryRules m where
196+ Handler MysteryRules m where
195 handle (MkG w g got []) Won k = k () (GameWon w)
197 handle (MkG w g got []) Won k = k () (GameWon w)
196 handle (MkG w Z got m) Lost k = k () (GameLost w)
198 handle (MkG w Z got m) Lost k = k () (GameLost w)
198− handle st StrState k = k (show st) st
200+ handle st Get k = k (show st) st
199 handle st (NewWord w) k = k () (initState w)
201 handle st (NewWord w) k = k () (initState w)
201 handle (MkG w (S g) got m) (Guess x) k =
203 handle (MkG w (S g) got m) (Guess x) k =
@@ -219,8 +221,8 @@ for the game which uses the ``MYSTERY`` effect:
220.. code-block:: idris
222.. code-block:: idris
222− game : { [MYSTERY (Running (S g) w), STDIO] ==>
224+ game : Eff () [MYSTERY (Running (S g) w), STDIO]
223− [MYSTERY NotRunning, STDIO] } Eff ()
225+ [MYSTERY NotRunning, STDIO]
225The type indicates that the game must start in a running state, with
227The type indicates that the game must start in a running state, with
226some guesses available, and eventually reach a not-running state (i.e.
228some guesses available, and eventually reach a not-running state (i.e.
@@ -239,12 +241,12 @@ running ``game``:
240.. code-block:: idris
242.. code-block:: idris
242− runGame : { [MYSTERY NotRunning, RND, SYSTEM, STDIO] } Eff ()
244+ runGame : Eff () [MYSTERY NotRunning, RND, SYSTEM, STDIO]
243− runGame = do srand (cast !time)
245+ runGame = do srand !time
244− let w = index !(rndFin WEWEWE) words
246+ let w = index !(rndFin _) words
245− NewWord w
247+ call $ NewWord w
247− putStrLn !StrState
249+ putStrLn !(call Get)
249We use the system time (``time`` from the ``SYSTEM`` effect; see
251We use the system time (``time`` from the ``SYSTEM`` effect; see
250Appendix :ref:`sect-appendix`) to initialise the random number
252Appendix :ref:`sect-appendix`) to initialise the random number
@@ -262,7 +264,7 @@ generator, then pick a random ``Fin`` to index into a list of
264 Rather than have to explicitly declare a type with the vector’s
266 Rather than have to explicitly declare a type with the vector’s
265− length, it is convenient to give a metavariable ``?wtype`` and let
267+ length, it is convenient to give a hole ``?wtype`` and let
266 Idris’s proof search mechanism find the type. This is a
268 Idris’s proof search mechanism find the type. This is a
267 limited form of type inference, but very useful in practice.
269 limited form of type inference, but very useful in practice.
@@ -271,11 +273,11 @@ presented below:
272.. code-block:: idris
274.. code-block:: idris
274− game : { [MYSTERY (Running (S g) w), STDIO] ==>
276+ game : Eff () [MYSTERY (Running (S g) w), STDIO]
275− [MYSTERY NotRunning, STDIO] } Eff ()
277+ [MYSTERY NotRunning, STDIO]
276 game {w=Z} = Won
278 game {w=Z} = Won
277 game {w=S _}
279 game {w=S _}
278− = do putStrLn !StrState
280+ = do putStrLn !Get
279 putStr "Enter guess: "
281 putStr "Enter guess: "
280 let guess = trim !getStr
282 let guess = trim !getStr
281 case choose (not (guess == "")) of
283 case choose (not (guess == "")) of
@@ -283,9 +285,8 @@ presented below:
283 (Right p) => do putStrLn "Invalid input!"
285 (Right p) => do putStrLn "Invalid input!"
286− processGuess : Char -> { [MYSTERY (Running (S g) (S w)), STDIO] ==>
288+ processGuess : Char -> Eff () [MYSTERY (Running (S g) (S w)), STDIO]
287− [MYSTERY NotRunning, STDIO] }
289+ [MYSTERY NotRunning, STDIO]
289 processGuess {g} {w} c
290 processGuess {g} {w} c
290 = case !(Main.Guess c) of
291 = case !(Main.Guess c) of
291 True => do putStrLn "Good guess!"
292 True => do putStrLn "Good guess!"
@@ -315,16 +316,11 @@ transitions for ``MysteryRules``. Then, when implementing ``game`` at
315first, any incorrect assumption was caught as a type error. The
316first, any incorrect assumption was caught as a type error. The
316following errors were caught during development:
317following errors were caught during development:
318−- Not realising that allowing ``NewWord`` to be an arbitrary string
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.
319− would mean that ``game`` would have to deal with a zero-length word
320− as a starting state.
322−- Forgetting to check whether a game was won before recursively
323− calling ``processGuess``, thus accidentally continuing a finished
321+- Forgetting to check whether a game was won before recursively calling ``processGuess``, thus accidentally continuing a finished game.
326−- Accidentally checking the number of missing letters, rather than the
323+- Accidentally checking the number of missing letters, rather than the number of remaining guesses, when checking if a game was lost.
327− number of remaining guesses, when checking if a game was lost.
329These are, of course, simple errors, but were caught by the type
325These are, of course, simple errors, but were caught by the type
330checker before any testing of the game.
326checker before any testing of the game.
docs/effects/impleff.rst+78−67
@@ -23,24 +23,11 @@ available. Stateful operations are described as follows:
23.. code-block:: idris
23.. code-block:: idris
25 data State : Effect where
25 data State : Effect where
26− Get : { a } State a
26+ Get : State a a (\x => a)
27− Put : b -> { a ==> b } State ()
27+ Put : b -> State () a (\x => b)
29−Each effect is associated with a *resource*, the type of which is
30−given with the notation ``{ x ==> x’ }``. This notation gives the
31−resource type expected by each operation, and how it updates when the
32−operation is run. Here, it means:
34−- ``Get`` takes no arguments. It has a resource of type ``a``, which
35− is not updated, and running the ``Get`` operation returns something
38−- ``Put`` takes a ``b`` as an argument. It has a resource of type
39− ``a`` on input, which is updated to a resource of type
40− ``b``. Running the ``Put`` operation returns the element of the
43−``Effect`` itself is a type synonym, declared as follows:
29+``Effect`` itself is a type synonym, giving the required type for an
45.. code-block:: idris
32.. code-block:: idris
@@ -49,18 +36,41 @@ operation is run. Here, it means:
49 (input_resource : Type) ->
36 (input_resource : Type) ->
50 (output_resource : result -> Type) -> Type
37 (output_resource : result -> Type) -> Type
52−That is, an effectful operation returns something of type ``result``,
39+Each effect is associated with a *resource*. The second argument to
53−has an input resource of type ``input_resource``, and a function
40+an effect signature is the resource type on *input* to an operation,
54−``output_resource`` which computes the output resource type from the
41+and the third is a function which computes the resource type on
55−result. We use the same syntactic sugar as with ``Eff`` to make effect
42+*output*. Here, it means:
56−declarations more readable. It is defined as follows in the library:
43+
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
58.. code-block:: idris
53.. code-block:: idris
60− syntax "{" [inst] "}" [eff] = eff inst (\result => inst)
55+ data State : Effect where
61− syntax "{" [inst] "==>" "{" {b} "}" [outst] "}" [eff]
56+ Get : sig State a a
62− = eff inst (\b => outst)
57+ Put : b -> sig State () a b
63− syntax "{" [inst] "==>" [outst] "}" [eff] = eff inst (\result => outst)
58+
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
65In order to convert ``State`` (of type ``Effect``) into something
75In order to convert ``State`` (of type ``Effect``) into something
66usable in an effects list, of type ``EFFECT``, we write the following:
76usable in an effects list, of type ``EFFECT``, we write the following:
@@ -83,26 +93,24 @@ Recall that to run an effectful program in ``Eff``, we use one of the
83``run`` family of functions to run the program in a particular
93``run`` family of functions to run the program in a particular
84computation context ``m``. For each effect, therefore, we must explain
94computation context ``m``. For each effect, therefore, we must explain
85how it is executed in a particular computation context for ``run`` to
95how it is executed in a particular computation context for ``run`` to
86−work in that context. This is achieved with the following type class:
96+work in that context. This is achieved with the following interface:
88.. code-block:: idris
98.. code-block:: idris
90− class Handler (e : Effect) (m : Type -> Type) where
100+ interface Handler (e : Effect) (m : Type -> Type) where
91 handle : resource -> (eff : e t resource resource') ->
101 handle : resource -> (eff : e t resource resource') ->
92 ((x : t) -> resource' x -> m a) -> m a
102 ((x : t) -> resource' x -> m a) -> m a
94−We have already seen some instance declarations in the effect
104+We have already seen some implementation declarations in the effect
95−summaries in Section :ref:`sect-simpleff`. An instance of ``Handler e
105+summaries in Section :ref:`sect-simpleff`. An implementation of ``Handler e
96m`` means that the effect declared with signature ``e`` can be run in
106m`` means that the effect declared with signature ``e`` can be run in
97computation context ``m``. The ``handle`` function takes:
107computation context ``m``. The ``handle`` function takes:
99−- The ``resource`` on input (so, the current value of the state for
109+- The ``resource`` on input (so, the current value of the state for ``State``)
102- The effectful operation (either ``Get`` or ``Put x`` for ``State``)
111- The effectful operation (either ``Get`` or ``Put x`` for ``State``)
104−- A *continuation*, which we conventionally call ``k``, and should be
105− passed the result value of the operation, and an updated resource.
113+- A *continuation*, which we conventionally call ``k``, and should be passed the result value of the operation, and an updated resource.
107There are two reasons for taking a continuation here: firstly, this is
115There are two reasons for taking a continuation here: firstly, this is
108neater because there are multiple return values (a new resource and
116neater because there are multiple return values (a new resource and
@@ -115,7 +123,7 @@ in the case of ``Get``, or passes on a new state, in the case of
116.. code-block:: idris
124.. code-block:: idris
118− instance Handler State m where
126+ Handler State m where
119 handle st Get k = k st st
127 handle st Get k = k st st
120 handle st (Put n) k = k () n
128 handle st (Put n) k = k () n
@@ -125,18 +133,18 @@ functions in ``Eff``, as follows:
126.. code-block:: idris
134.. code-block:: idris
128− get : { [STATE x] } Eff x
136+ get : Eff x [STATE x]
129 get = call Get
137 get = call Get
131− put : x -> { [STATE x] } Eff ()
139+ put : x -> Eff () [STATE x]
132 put val = call (Put val)
140 put val = call (Put val)
134− putM : y -> { [STATE x] ==> [STATE y] } Eff ()
142+ putM : y -> Eff () [STATE x] [STATE y]
135 putM val = call (Put val)
143 putM val = call (Put val)
137**An implementation detail (aside):** The ``call`` function converts
145**An implementation detail (aside):** The ``call`` function converts
138an ``Effect`` to a function in ``Eff``, given a proof that the effect
146an ``Effect`` to a function in ``Eff``, given a proof that the effect
139−is available. This proof can be constructed automatically by , since
147+is available. This proof can be constructed automatically, since
140it is essentially an index into a statically known list of effects:
148it is essentially an index into a statically known list of effects:
142.. code-block:: idris
150.. code-block:: idris
@@ -162,23 +170,23 @@ The following listing summarises what is required to define the
162.. code-block:: idris
170.. code-block:: idris
164 data State : Effect where
172 data State : Effect where
165− Get : { a } State a
173+ Get : sig State a a
166− Put : b -> { a ==> b } State ()
174+ Put : b -> sig State () a b
168 STATE : Type -> EFFECT
176 STATE : Type -> EFFECT
169 STATE t = MkEff t State
177 STATE t = MkEff t State
171− instance Handler State m where
179+ Handler State m where
172 handle st Get k = k st st
180 handle st Get k = k st st
173 handle st (Put n) k = k () n
181 handle st (Put n) k = k () n
175− get : { [STATE x] } Eff x
183+ get : Eff x [STATE x]
176 get = call Get
184 get = call Get
178− put : x -> { [STATE x] } Eff ()
186+ put : x -> Eff () [STATE x]
179 put val = call (Put val)
187 put val = call (Put val)
181− putM : y -> { [STATE x] ==> [STATE y] } Eff ()
189+ putM : y -> Eff () [STATE x] [STATE y]
182 putM val = call (Put val)
190 putM val = call (Put val)
@@ -198,18 +206,18 @@ directly.
198.. code-block:: idris
206.. code-block:: idris
200 data StdIO : Effect where
208 data StdIO : Effect where
201− PutStr : String -> { () } StdIO ()
209+ PutStr : String -> sig StdIO ()
202− GetStr : { () } StdIO String
210+ GetStr : sig StdIO String
203− PutCh : Char -> { () } StdIO ()
211+ PutCh : Char -> sig StdIO ()
204− GetCh : { () } StdIO Char
212+ GetCh : sig StdIO Char
206− instance Handler StdIO IO where
214+ Handler StdIO IO where
207 handle () (PutStr s) k = do putStr s; k () ()
215 handle () (PutStr s) k = do putStr s; k () ()
208 handle () GetStr k = do x <- getLine; k x ()
216 handle () GetStr k = do x <- getLine; k x ()
209 handle () (PutCh c) k = do putChar c; k () ()
217 handle () (PutCh c) k = do putChar c; k () ()
210 handle () GetCh k = do x <- getChar; k x ()
218 handle () GetCh k = do x <- getChar; k x ()
212− instance Handler StdIO (IOExcept a) where
220+ Handler StdIO (IOExcept a) where
213 handle () (PutStr s) k = do ioe_lift $ putStr s; k () ()
221 handle () (PutStr s) k = do ioe_lift $ putStr s; k () ()
214 handle () GetStr k = do x <- ioe_lift $ getLine; k x ()
222 handle () GetStr k = do x <- ioe_lift $ getLine; k x ()
215 handle () (PutCh c) k = do ioe_lift $ putChar c; k () ()
223 handle () (PutCh c) k = do ioe_lift $ putChar c; k () ()
@@ -231,12 +239,12 @@ error.
231.. code-block:: idris
239.. code-block:: idris
233 data Exception : Type -> Effect where
241 data Exception : Type -> Effect where
234− Raise : a -> { () } Exception a b
242+ Raise : a -> sig (Exception a) b
236− instance Handler (Exception a) Maybe where
244+ Handler (Exception a) Maybe where
237 handle _ (Raise e) k = Nothing
245 handle _ (Raise e) k = Nothing
239− instance Handler (Exception a) List where
247+ Handler (Exception a) List where
240 handle _ (Raise e) k = []
248 handle _ (Raise e) k = []
242 EXCEPTION : Type -> EFFECT
250 EXCEPTION : Type -> EFFECT
@@ -255,16 +263,16 @@ value.
255.. code-block:: idris
263.. code-block:: idris
257 data Selection : Effect where
265 data Selection : Effect where
258− Select : List a -> { () } Selection a
266+ Select : List a -> sig Selection a
260− instance Handler Selection Maybe where
268+ Handler Selection Maybe where
261 handle _ (Select xs) k = tryAll xs where
269 handle _ (Select xs) k = tryAll xs where
262 tryAll [] = Nothing
270 tryAll [] = Nothing
263 tryAll (x :: xs) = case k x () of
271 tryAll (x :: xs) = case k x () of
264 Nothing => tryAll xs
272 Nothing => tryAll xs
265 Just v => Just v
273 Just v => Just v
267− instance Handler Selection List where
275+ Handler Selection List where
268 handle r (Select xs) k = concatMap (\x => k x r) xs
276 handle r (Select xs) k = concatMap (\x => k x r) xs
270 SELECT : EFFECT
278 SELECT : EFFECT
@@ -274,7 +282,7 @@ value.
274Here, the continuation is called multiple times in each handler, for
282Here, the continuation is called multiple times in each handler, for
275each value in the list of possible values. In the ``List`` handler, we
283each value in the list of possible values. In the ``List`` handler, we
276accumulate all successful results, and in the ``Maybe`` handler we try
284accumulate all successful results, and in the ``Maybe`` handler we try
277−the first value in the last, and try later values only if that fails.
285+the first value in the list, and try later values only if that fails.
279File Management
287File Management
280===============
288===============
@@ -289,15 +297,18 @@ the equivalent ``Eff`` programs.
289.. code-block:: idris
297.. code-block:: idris
291 data FileIO : Effect where
299 data FileIO : Effect where
292− Open : String -> (m : Mode) ->
300+ Open : (fname: String)
293− {() ==> {res} if res then OpenFile m else ()} FileIO Bool
301+ -> (m : Mode)
294− Close : {OpenFile m ==> ()} FileIO ()
302+ -> sig FileIO Bool () (\res => case res of
295−
303+ True => OpenFile m
305+ Close : sig FileIO () (OpenFile m)
296− ReadLine : {OpenFile Read} FileIO String
307+ ReadLine : sig FileIO String (OpenFile Read)
297− WriteLine : String -> {OpenFile Write} FileIO ()
308+ WriteLine : String -> sig FileIO () (OpenFile Write)
298− EOF : {OpenFile Read} FileIO Bool
309+ EOF : sig FileIO Bool (OpenFile Read)
300− instance Handler FileIO IO where
311+ Handler FileIO IO where
301 handle () (Open fname m) k = do h <- openFile fname m
312 handle () (Open fname m) k = do h <- openFile fname m
302 if !(validFile h)
313 if !(validFile h)
303 then k True (FH h)
314 then k True (FH h)
docs/effects/index.rst+14−2
@@ -6,14 +6,26 @@ The Effects Tutorial
7A tutorial on the `Effects` package in `Idris`.
7A 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`).
11 The documentation for Idris has been published under the Creative
23 The documentation for Idris has been published under the Creative
12 Commons CC0 License. As such to the extent possible under law, *The
24 Commons CC0 License. As such to the extent possible under law, *The
13− Idris Community* has waived all copyright and related or neighboring
25+ Idris Community* has waived all copyright and related or neighbouring
14 rights to Documentation for Idris.
26 rights to Documentation for Idris.
16− More information concerning the CC0 can be found online at: http://creativecommons.org/publicdomain/zero/1.0/
28+ More information concerning the CC0 can be found online at: https://creativecommons.org/publicdomain/zero/1.0/
18.. toctree::
30.. toctree::
19 :maxdepth: 1
31 :maxdepth: 1
docs/effects/introduction.rst+9−12
@@ -3,7 +3,7 @@ Introduction
3************
3************
5Pure functional languages with dependent types such as `Idris
5Pure functional languages with dependent types such as `Idris
6−<http://idris-lang.org/>`_ support reasoning about programs directly
6+<https://www.idris-lang.org/>`_ support reasoning about programs directly
7in the type system, promising that we can *know* a program will run
7in the type system, promising that we can *know* a program will run
8correctly (i.e. according to the specification in its type) simply
8correctly (i.e. according to the specification in its type) simply
9because it compiles. Realistically, though, things are not so simple:
9because it compiles. Realistically, though, things are not so simple:
@@ -17,7 +17,8 @@ exceptions, and verified resource management.
17This tutorial assumes familiarity with pure programming in Idris,
17This tutorial assumes familiarity with pure programming in Idris,
18as described in Sections 1–6 of the main tutorial [1]_. The examples
18as described in Sections 1–6 of the main tutorial [1]_. The examples
19presented are tested with Idris and can be found in the
19presented are tested with Idris and can be found in the
20−examples directory of the Idris repository.
20+examples directory of the Idris repository. The ``-p effects`` flag
21+is needed when starting Idris.
22Consider, for example, the following introductory function which
23Consider, for example, the following introductory function which
23illustrates the kind of properties which can be expressed in the type
24illustrates the kind of properties which can be expressed in the type
@@ -37,11 +38,9 @@ introductory tutorials, is “How do I turn this into a program?” That is,
37given some lists entered by a user, how do we get into a position to be
38given some lists entered by a user, how do we get into a position to be
38able to apply the ``vadd`` function? Before doing so, we will have to:
39able to apply the ``vadd`` function? Before doing so, we will have to:
40−- Read user input, either from the keyboard, a file, or some other
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`` s
43+- Check that the user inputs are valid, i.e. contain only ``Int`` and are the same length, and report an error if not.
44− and are the same length, and report an error if not.
46- Write output
45- Write output
@@ -55,7 +54,7 @@ this specific example later.
55Hello world
54Hello world
56===========
55===========
58−To give an idea of how programs with effects look in , here is the
57+To give an idea of how programs with effects look, here is the
59ubiquitous “Hello world” program, written using the ``Effects``
58ubiquitous “Hello world” program, written using the ``Effects``
@@ -66,8 +65,8 @@ library:
66 import Effects
65 import Effects
67 import Effect.StdIO
66 import Effect.StdIO
69− hello : {[STDIO]} Eff ()
68+ hello : Eff () [STDIO]
70− hello = putStrLn “Hello world!”
69+ hello = putStrLn "Hello world!"
72 main : IO ()
71 main : IO ()
73 main = run hello
72 main = run hello
@@ -108,6 +107,4 @@ accurately. References to further reading are given in Section
108:ref:`sect-further`.
107:ref:`sect-further`.
111− You do not, however, need to know what a monad is. A correctness
110+ You do not, however, need to know what a monad is!
112− property of this tutorial is that the word “monad” should appear
113− exactly twice, both in this footnote.
docs/effects/simpleeff.rst+93−90
@@ -14,14 +14,14 @@ in a module ``Effect.State``
15 STATE : Type -> EFFECT
15 STATE : Type -> EFFECT
17− get : { [STATE x] } Eff x
17+ get : Eff x [STATE x]
18− put : x -> { [STATE x] } Eff ()
18+ put : x -> Eff () [STATE x]
19− putM : y -> { [STATE x] ==> [STATE y] } Eff ()
19+ putM : y -> Eff () [STATE x] [STATE y]
20− update : (x -> x) -> { [STATE x] } Eff ()
20+ update : (x -> x) -> Eff () [STATE x]
22− instance Handler State m
22+ Handler State m where { ... }
24−The last line, ``instance Handler State m``, means that the ``STATE``
24+The last line, ``Handler State m where { ... }``, means that the ``STATE``
25effect is usable in any computation context ``m``. That is, a program
25effect is usable in any computation context ``m``. That is, a program
26which uses this effect and returns something of type ``a`` can be
26which uses this effect and returns something of type ``a`` can be
27evaluated to something of type ``m a`` using ``run``, for any
27evaluated to something of type ``m a`` using ``run``, for any
@@ -56,15 +56,15 @@ can perform (or at the very least simulate) console I/O:
57 STDIO : EFFECT
57 STDIO : EFFECT
59− putChar : Char -> { [STDIO] } Eff ()
59+ putChar : Char -> Eff () [STDIO]
60− putStr : String -> { [STDIO] } Eff ()
60+ putStr : String -> Eff () [STDIO]
61− putStrLn : String -> { [STDIO] } Eff ()
61+ putStrLn : String -> Eff () [STDIO]
63− getStr : { [STDIO] } Eff String
63+ getStr : Eff String [STDIO]
64− getChar : { [STDIO] } Eff Char
64+ getChar : Eff Char [STDIO]
66− instance Handler StdIO IO
66+ Handler StdIO IO where { ... }
67− instance Handler StdIO (IOExcept a)
67+ Handler StdIO (IOExcept a) where { ... }
@@ -74,7 +74,7 @@ as follows:
75.. code-block:: idris
75.. code-block:: idris
77− hello : { [STDIO] } Eff ()
77+ hello : Eff () [STDIO]
78 hello = do putStr "Name? "
78 hello = do putStr "Name? "
79 x <- getStr
79 x <- getStr
80 putStrLn ("Hello " ++ trim x ++ "!")
80 putStrLn ("Hello " ++ trim x ++ "!")
@@ -94,7 +94,7 @@ getStr``, since we only use the string that is read once:
95.. code-block:: idris
95.. code-block:: idris
97− hello : { [STDIO] } Eff ()
97+ hello : Eff () [STDIO]
98 hello = do putStr "Name? "
98 hello = do putStr "Name? "
99 putStrLn ("Hello " ++ trim !getStr ++ "!")
99 putStrLn ("Hello " ++ trim !getStr ++ "!")
@@ -104,7 +104,7 @@ said hello to:
105.. code-block:: idris
105.. code-block:: idris
107− hello : { [STATE Int, STDIO] } Eff ()
107+ hello : Eff () [STATE Int, STDIO]
108 hello = do putStr "Name? "
108 hello = do putStr "Name? "
109 putStrLn ("Hello " ++ trim !getStr ++ "!")
109 putStrLn ("Hello " ++ trim !getStr ++ "!")
110 update (+1)
110 update (+1)
@@ -120,7 +120,7 @@ Aside: Resource Types
120---------------------
120---------------------
122To find out the resource type of an effect, if necessary (for example
122To find out the resource type of an effect, if necessary (for example
123−if we want to initialise a resource explicitiy with ``runInit`` rather
123+if we want to initialise a resource explicitly with ``runInit`` rather
124than using a default value with ``run``) we can run the
124than using a default value with ``run``) we can run the
125``resourceType`` function at the REPL:
125``resourceType`` function at the REPL:
@@ -146,13 +146,13 @@ generally:
147 EXCEPTION : Type -> EFFECT
147 EXCEPTION : Type -> EFFECT
149− raise : a -> { [EXCEPTION a ] } Eff b
149+ raise : a -> Eff b [EXCEPTION a]
151− instance Handler (Exception a) Maybe
151+ Handler (Exception a) Maybe where { ... }
152− instance Handler (Exception a) List
152+ Handler (Exception a) List where { ... }
153− instance Handler (Exception a) (Either a)
153+ Handler (Exception a) (Either a) where { ... }
154− instance Handler (Exception a) (IOExcept a)
154+ Handler (Exception a) (IOExcept a) where { ... }
155− instance Show a => Handler (Exception a) IO
155+ Show a => Handler (Exception a) IO where { ... }
@@ -161,13 +161,13 @@ Suppose we have a ``String`` which is expected to represent an integer
161in the range ``0`` to ``n``. We can write a function ``parseNumber``
161in the range ``0`` to ``n``. We can write a function ``parseNumber``
162which returns an ``Int`` if parsing the string returns a number in the
162which returns an ``Int`` if parsing the string returns a number in the
163appropriate range, or throws an exception otherwise. Exceptions are
163appropriate range, or throws an exception otherwise. Exceptions are
164−paramaterised by an error type:
164+parameterised by an error type:
166.. code-block:: idris
166.. code-block:: idris
168− data Err = NotANumber | OutOfRange
168+ data Error = NotANumber | OutOfRange
170− parseNumber : Int -> String -> { [EXCEPTION Err] } Eff Int
170+ parseNumber : Int -> String -> Eff Int [EXCEPTION Error]
171 parseNumber num str
171 parseNumber num str
172 = if all isDigit (unpack str)
172 = if all isDigit (unpack str)
173 then let x = cast str in
173 then let x = cast str in
@@ -178,23 +178,23 @@ paramaterised by an error type:
179Programs which support the ``EXCEPTION`` effect can be run in any
179Programs which support the ``EXCEPTION`` effect can be run in any
180context which has some way of throwing errors, for example, we can run
180context which has some way of throwing errors, for example, we can run
181−``parseNumber`` in the ``Either Err`` context. It returns a value of
181+``parseNumber`` in the ``Either Error`` context. It returns a value of
182the form ``Right x`` if successful:
182the form ``Right x`` if successful:
184.. code-block:: idris
184.. code-block:: idris
186− *Exception> the (Either Err Int) $ run (parseNumber 42 "20")
186+ *Exception> the (Either Error Int) $ run (parseNumber 42 "20")
187− Right 20 : Either Err Int
187+ Right 20 : Either Error Int
189Or ``Left e`` on failure, carrying the appropriate exception:
189Or ``Left e`` on failure, carrying the appropriate exception:
191.. code-block:: idris
191.. code-block:: idris
193− *Exception> the (Either Err Int) $ run (parseNumber 42 "50")
193+ *Exception> the (Either Error Int) $ run (parseNumber 42 "50")
194− Left OutOfRange : Either Err Int
194+ Left OutOfRange : Either Error Int
196− *Exception> the (Either Err Int) $ run (parseNumber 42 "twenty")
196+ *Exception> the (Either Error Int) $ run (parseNumber 42 "twenty")
197− Left NotANumber : Either Err Int
197+ Left NotANumber : Either Error Int
199In fact, we can do a little bit better with ``parseNumber``, and have
199In fact, we can do a little bit better with ``parseNumber``, and have
200it return a *proof* that the integer is in the required range along
200it return a *proof* that the integer is in the required range along
@@ -212,7 +212,8 @@ from the result of a dynamic check:
213.. code-block:: idris
213.. code-block:: idris
215− data So : Bool -> Type = Oh : So True
215+ data So : Bool -> Type where
217 choose : (b : Bool) -> Either (So b) (So (not b))
218 choose : (b : Bool) -> Either (So b) (So (not b))
@@ -222,7 +223,7 @@ the boundedness proof:
223.. code-block:: idris
224.. code-block:: idris
225− parseNumber : (x : Int) -> String -> { [EXCEPTION Err] } Eff (Bounded x)
226+ parseNumber : (x : Int) -> String -> Eff (Bounded x) [EXCEPTION Error]
226 parseNumber x str
227 parseNumber x str
227 = if all isDigit (unpack str)
228 = if all isDigit (unpack str)
228 then let num = cast str in
229 then let num = cast str in
@@ -243,11 +244,11 @@ Random number generation is also implemented by the library, in module
244 RND : EFFECT
245 RND : EFFECT
246− srand : Integer -> { [RND] } Eff ()
247+ srand : Integer -> Eff () [RND]
247− rndInt : Integer -> Integer -> { [RND] } Eff Integer
248+ rndInt : Integer -> Integer -> Eff Integer [RND]
248− rndFin : (k : Nat) -> { [RND] } Eff (Fin (S k))
249+ rndFin : (k : Nat) -> Eff (Fin (S k)) [RND]
250− instance Handler Random m
251+ Handler Random m where { ... }
252Random number generation is considered side-effecting because its
253Random number generation is considered side-effecting because its
253implementation generally relies on some external source of randomness.
254implementation generally relies on some external source of randomness.
@@ -272,14 +273,14 @@ correct:
273.. code-block:: idris
274.. code-block:: idris
275− guess : Int -> { [STDIO] } Eff ()
276+ guess : Int -> Eff () [STDIO]
277For reference, the code for ``guess`` is given below:
278For reference, the code for ``guess`` is given below:
279.. _eff-game:
280.. _eff-game:
280.. code-block:: idris
281.. code-block:: idris
282− guess : Int -> { [STDIO] } Eff ()
283+ guess : Int -> Eff () [STDIO]
283 guess target
284 guess target
284 = do putStr "Guess: "
285 = do putStr "Guess: "
285 case run {m=Maybe} (parseNumber 100 (trim !getStr)) of
286 case run {m=Maybe} (parseNumber 100 (trim !getStr)) of
@@ -303,7 +304,7 @@ having set up the random number generator with a seed, then run
304.. code-block:: idris
305.. code-block:: idris
306− game : { [RND, STDIO] } Eff ()
307+ game : Eff () [RND, STDIO]
307 game = do srand 123456789
308 game = do srand 123456789
308 guess (fromInteger !(rndInt 0 100))
309 guess (fromInteger !(rndInt 0 100))
@@ -331,10 +332,10 @@ succeeds:
332 SELECT : EFFECT
333 SELECT : EFFECT
334− select : List a -> { [SELECT] } Eff a
335+ select : List a -> Eff a [SELECT]
336− instance Handler Selection Maybe
337+ Handler Selection Maybe where { ... }
337− instance Handler Selection List
338+ Handler Selection List where { ... }
@@ -346,7 +347,7 @@ of values which does not satisfy the constraint:
347.. code-block:: idris
348.. code-block:: idris
349− triple : Int -> { [SELECT, EXCEPTION String] } Eff (Int, Int, Int)
350+ triple : Int -> Eff (Int, Int, Int) [SELECT, EXCEPTION String]
350 triple max = do z <- select [1..max]
351 triple max = do z <- select [1..max]
351 y <- select [1..z]
352 y <- select [1..z]
352 x <- select [1..y]
353 x <- select [1..y]
@@ -382,7 +383,7 @@ definition:
383 vadd : Vect n Int -> Vect n Int -> Vect n Int
384 vadd : Vect n Int -> Vect n Int -> Vect n Int
384 vadd [] [] = []
385 vadd [] [] = []
385− vadd (x :: idris xs) (y :: ys) = x + y :: vadd xs ys
386+ vadd (x :: xs) (y :: ys) = x + y :: vadd xs ys
387Using , we can set up a program so that it reads input from a user,
388Using , we can set up a program so that it reads input from a user,
388checks that the input is valid (i.e both vectors contain integers, and
389checks that the input is valid (i.e both vectors contain integers, and
@@ -396,7 +397,7 @@ they are equal:
396.. code-block:: idris
397.. code-block:: idris
398 vadd_check : Vect n Int -> Vect m Int ->
399 vadd_check : Vect n Int -> Vect m Int ->
399− { [EXCEPTION String] } Eff (Vect m Int)
400+ Eff (Vect m Int) [EXCEPTION String]
400 vadd_check {n} {m} xs ys with (decEq n m)
401 vadd_check {n} {m} xs ys with (decEq n m)
401 vadd_check {n} {m=n} xs ys | (Yes Refl) = pure (vadd xs ys)
402 vadd_check {n} {m=n} xs ys | (Yes Refl) = pure (vadd xs ys)
402 vadd_check {n} {m} xs ys | (No contra) = raise "Length mismatch"
403 vadd_check {n} {m} xs ys | (No contra) = raise "Length mismatch"
@@ -406,14 +407,32 @@ following type:
407.. code-block:: idris
408.. code-block:: idris
409− read_vec : { [STDIO] } Eff (p ** Vect p Int)
410+ read_vec : Eff (p ** Vect p Int) [STDIO]
411This returns a dependent pair of a length, and a vector of that
412This returns a dependent pair of a length, and a vector of that
412length, because we cannot know in advance how many integers the user
413length, because we cannot know in advance how many integers the user
413−is going to input. One way to implement this function, using ``-1`` to
414−indicate the end of input, is shown in Listing [readvec]. This uses a
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"
415−variation on ``parseNumber`` which does not require a number to be
434+This uses a variation on ``parseNumber`` which does not require a
416−within range.
435+number to be within range.
418Finally, we write a program which reads two vectors and prints the
437Finally, we write a program which reads two vectors and prints the
419result of pairwise addition of them, throwing an exception if the
438result of pairwise addition of them, throwing an exception if the
@@ -421,7 +440,7 @@ inputs are of differing lengths:
422.. code-block:: idris
441.. code-block:: idris
424− do_vadd : { [STDIO, EXCEPTION String] } Eff ()
443+ do_vadd : Eff () [STDIO, EXCEPTION String]
425 do_vadd = do putStrLn "Vector 1"
444 do_vadd = do putStrLn "Vector 1"
426 (_ ** xs) <- read_vec
445 (_ ** xs) <- read_vec
427 putStrLn "Vector 2"
446 putStrLn "Vector 2"
@@ -434,23 +453,6 @@ equal. This does not stop us reading vectors from user input, but it
434does require that the lengths are checked and any discrepancy is dealt
453does require that the lengths are checked and any discrepancy is dealt
435with gracefully.
454with gracefully.
437−.. code-block:: idris
439− read_vec : { [STDIO] } Eff (p ** Vect p Int)
440− read_vec = do putStr "Number (-1 when done): "
441− case run (parseNumber (trim !getStr)) of
442− Nothing => do putStrLn "Input error"
444− Just v => if (v /= -1)
445− then do (_ ** xs) <- read_vec
449− parseNumber : String -> { [EXCEPTION String] } Eff Int
451− = if all (\x => isDigit x || x == '-') (unpack str)
452− then pure (cast str)
453− else raise "Not a number"
455Example: An Expression Calculator
457Example: An Expression Calculator
456=================================
458=================================
@@ -493,9 +495,9 @@ values:
493 Env : Type
495 Env : Type
494 Env = List (String, Integer)
496 Env = List (String, Integer)
496− eval : Expr -> { [EXCEPTION String, STATE Env] } Eff Integer
498+ eval : Expr -> Eff Integer [EXCEPTION String, STATE Env]
497− eval (Val x) = return x
499+ eval (Val x) = pure x
498− eval (Add l r) = return $ !(eval l) + !(eval r)
500+ eval (Add l r) = pure $ !(eval l) + !(eval r)
500Note that we are using ``!``-notation to avoid having to bind
502Note that we are using ``!``-notation to avoid having to bind
501subexpressions in a ``do`` block. Next, we add a case for evaluating
503subexpressions in a ``do`` block. Next, we add a case for evaluating
@@ -505,7 +507,7 @@ subexpressions in a ``do`` block. Next, we add a case for evaluating
506 eval (Var x) = case lookup x !get of
508 eval (Var x) = case lookup x !get of
507 Nothing => raise $ "No such variable " ++ x
509 Nothing => raise $ "No such variable " ++ x
508− Just val => return val
510+ Just val => pure val
510This retrieves the state (with ``get``, supported by the ``STATE Env``
512This retrieves the state (with ``get``, supported by the ``STATE Env``
511effect) and raises an exception if the variable is not in the
513effect) and raises an exception if the variable is not in the
@@ -520,7 +522,7 @@ sets the state then invokes ``eval``:
521 runEval : List (String, Integer) -> Expr -> Maybe Integer
523 runEval : List (String, Integer) -> Expr -> Maybe Integer
522 runEval args expr = run (eval' expr)
524 runEval args expr = run (eval' expr)
523− where eval' : Expr -> { [EXCEPTION String, STATE Env] } Eff Integer
525+ where eval' : Expr -> Eff Integer [EXCEPTION String, STATE Env]
524 eval' e = do put args
526 eval' e = do put args
@@ -542,12 +544,12 @@ which gives a random number up to a maximum value:
542 | Random Integer
544 | Random Integer
544Then, we need to deal with the new case, making sure that we extend
546Then, we need to deal with the new case, making sure that we extend
545−the list of events to include ``RND``. It doen’t matter where ``RND``
547+the list of events to include ``RND``. It doesn't matter where ``RND``
546appears in the list, as long as it is present:
548appears in the list, as long as it is present:
548.. code-block:: idris
550.. code-block:: idris
550− eval : Expr -> { [EXCEPTION String, RND, STATE Env] } Eff Integer
552+ eval : Expr -> Eff Integer [EXCEPTION String, RND, STATE Env]
552 eval (Random upper) = rndInt 0 upper
554 eval (Random upper) = rndInt 0 upper
@@ -558,7 +560,7 @@ has been generated:
559 eval (Random upper) = do val <- rndInt 0 upper
561 eval (Random upper) = do val <- rndInt 0 upper
560 putStrLn (show val)
562 putStrLn (show val)
561− return val
563+ pure val
563If we try this without extending the effects list, we would see an
565If we try this without extending the effects list, we would see an
564error something like the following:
566error something like the following:
@@ -575,18 +577,19 @@ this simply by updating the type of ``eval`` to include ``STDIO``.
576.. code-block:: idris
578.. code-block:: idris
578− eval : Expr -> { [STDIO, EXCEPTION String, RND, STATE Env] } Eff Integer
580+ eval : Expr -> Eff Integer [STDIO, EXCEPTION String, RND, STATE Env]
580−Note that using ``STDIO`` will restrict the number of contexts in
582+.. note:: Using ``STDIO`` will restrict the number of contexts in
581−which ``eval`` can be ``run`` to those which support ``STDIO``, such
583+ which ``eval`` can be ``run`` to those which support
582−as ``IO``. Once effect lists get longer, it can be a good idea instead
584+ ``STDIO``, such as ``IO``. Once effect lists get longer, it
585+ can be a good idea instead to encapsulate sets of effects in
583−to encapsulate sets of effects in a type synonym. This is achieved as
586+ a type synonym. This is achieved as follows, simply by
584−follows, simply by defining a function which computes a type, since
587+ defining a function which computes a type, since types are
585−types are first class in Idris:
588+ first class in Idris:
587−.. code-block:: idris
590+ .. code-block:: idris
589− EvalEff : Type -> Type
592+ EvalEff : Type -> Type
590− EvalEff t = { [STDIO, EXCEPTION String, RND, STATE Env] } Eff t
593+ EvalEff t = Eff t [STDIO, EXCEPTION String, RND, STATE Env]
592− eval : Expr -> EvalEff Integer
595+ eval : Expr -> EvalEff Integer
docs/effects/state.rst+65−55
@@ -83,7 +83,7 @@ effectful program ``f`` has a type of the following form:
84.. code-block:: idris
84.. code-block:: idris
86− f : (x1 : a1) -> (x2 : a2) -> ... -> { effs } Eff t
86+ f : (x1 : a1) -> (x2 : a2) -> ... -> Eff t effs
88That is, the return type gives the effects that ``f`` supports
88That is, the return type gives the effects that ``f`` supports
89(``effs``, of type ``List EFFECT``) and the type the computation
89(``effs``, of type ``List EFFECT``) and the type the computation
@@ -92,7 +92,7 @@ following type:
93.. code-block:: idris
93.. code-block:: idris
95− treeTagAux : BTree a -> { [STATE Int] } Eff (BTree (Int, a))
95+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE Int]
97That is, ``treeTagAux`` has access to an integer state, because the
97That is, ``treeTagAux`` has access to an integer state, because the
98list of available effects includes ``STATE Int``. ``STATE`` is
98list of available effects includes ``STATE Int``. ``STATE`` is
@@ -141,8 +141,8 @@ following types, polymorphic in the state ``t`` they manage:
142.. code-block:: idris
142.. code-block:: idris
144− get : { [STATE t] } Eff t
144+ get : Eff t [STATE t]
145− put : t -> { [STATE t] } Eff ()
145+ put : t -> Eff () [STATE t]
147A program in ``Eff`` can call any other function in ``Eff`` provided
147A program in ``Eff`` can call any other function in ``Eff`` provided
148that the calling function supports at least the effects required by
148that the calling function supports at least the effects required by
@@ -168,7 +168,7 @@ instead of ``runPure``:
169.. code-block:: idris
169.. code-block:: idris
171− treeTagAux : BTree a -> { [STATE Int] } Eff (BTree (Int, a))
171+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE Int]
174 treeTag : (i : Int) -> BTree a -> IO (BTree (Int, a))
174 treeTag : (i : Int) -> BTree a -> IO (BTree (Int, a))
@@ -189,7 +189,7 @@ shown in Listing [introprog].
189 data BTree a = Leaf
189 data BTree a = Leaf
190 | Node (BTree a) a (BTree a)
190 | Node (BTree a) a (BTree a)
192− instance Show a => Show (BTree a) where
192+ Show a => Show (BTree a) where
193 show Leaf = "[]"
193 show Leaf = "[]"
194 show (Node l x r) = "[" ++ show l ++ " "
194 show (Node l x r) = "[" ++ show l ++ " "
195 ++ show x ++ " "
195 ++ show x ++ " "
@@ -202,7 +202,7 @@ shown in Listing [introprog].
203 (Node Leaf "Bob" Leaf))
203 (Node Leaf "Bob" Leaf))
205− treeTagAux : BTree a -> { [STATE Int] } Eff (BTree (Int, a))
205+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE Int]
206 treeTagAux Leaf = pure Leaf
206 treeTagAux Leaf = pure Leaf
207 treeTagAux (Node l x r) = do l' <- treeTagAux l
207 treeTagAux (Node l x r) = do l' <- treeTagAux l
@@ -227,29 +227,29 @@ here for illustrative purposes):
228.. code-block:: idris
228.. code-block:: idris
230− runPure : {env : Env id xs} -> { xs } Eff a -> a
230+ runPure : {env : Env id xs} -> Eff a xs -> a
231− run : Applicative m => {env : Env m xs} -> { xs } Eff a -> m a
231+ run : Applicative m => {env : Env m xs} -> Eff a xs -> m a
233The ``env`` argument is implicit, and initialised automatically where
233The ``env`` argument is implicit, and initialised automatically where
234−possible using default values given by instances of the following type
234+possible using default values given by implementations of the following
237.. code-block:: idris
237.. code-block:: idris
239− class Default a where
239+ interface Default a where
240 default : a
240 default : a
242−Instances of ``Default`` are defined for all primitive types, and many
242+Implementations of ``Default`` are defined for all primitive types, and many
243library types such as ``List``, ``Vect``, ``Maybe``, pairs, etc.
243library types such as ``List``, ``Vect``, ``Maybe``, pairs, etc.
244However, where no default value exists for a resource type (for
244However, where no default value exists for a resource type (for
245example, you may want a ``STATE`` type for which there is no
245example, you may want a ``STATE`` type for which there is no
246−``Default`` instance) the resource environment can be given explicitly
246+``Default`` implementation) the resource environment can be given explicitly
247using one of the following functions:
247using one of the following functions:
249.. code-block:: idris
249.. code-block:: idris
251− runPureInit : Env id xs -> { xs } Eff a -> a
251+ runPureInit : Env id xs -> Eff a xs -> a
252− runInit : Applicative m => Env m xs -> { xs } Eff a -> m a
252+ runInit : Applicative m => Env m xs -> Eff a xs -> m a
254To be well-typed, the environment must contain resources corresponding
254To be well-typed, the environment must contain resources corresponding
255exactly to the effects in ``xs``. For example, we could also have
255exactly to the effects in ``xs``. For example, we could also have
@@ -272,8 +272,7 @@ captured both of these values, e.g.:
273.. code-block:: idris
273.. code-block:: idris
275− treeTagAux : BTree a
275+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE (Int, Int)]
276− -> { [STATE (Int, Int)] } Eff (BTree (Int, a))
278Doing this, however, ties the two states together throughout (as well
277Doing this, however, ties the two states together throughout (as well
279as not indicating which integer is which). It would be nice to be able
278as not indicating which integer is which). It would be nice to be able
@@ -288,9 +287,9 @@ leaves and update the tag separately, by labelling them as follows:
289.. code-block:: idris
288.. code-block:: idris
291− treeTagAux : BTree a
290+ treeTagAux : BTree a -> Eff (BTree (Int, a))
292− -> {['Tag ::: STATE Int,
291+ ['Tag ::: STATE Int,
293− 'Leaves ::: STATE Int]} Eff (BTree (Int, a))
292+ 'Leaves ::: STATE Int]
295The ``:::`` operator allows an arbitrary label to be given to an
294The ``:::`` operator allows an arbitrary label to be given to an
296effect. This label can be any type—it is simply used to identify an
295effect. This label can be any type—it is simply used to identify an
@@ -320,11 +319,11 @@ applying a function to the current state.
321.. code-block:: idris
320.. code-block:: idris
323− update : (x -> x) -> { [STATE x] } Eff ()
322+ update : (x -> x) -> Eff () [STATE x]
325Finally, our top level ``treeTag`` function now returns a pair of the
324Finally, our top level ``treeTag`` function now returns a pair of the
326number of leaves, and the new tree. Resources for labelled effects are
325number of leaves, and the new tree. Resources for labelled effects are
327−intialised using the ``:=`` operator (reminisicent of assignment in an
326+initialised using the ``:=`` operator (reminiscent of assignment in an
328imperative language):
327imperative language):
330.. code-block:: idris
329.. code-block:: idris
@@ -339,8 +338,7 @@ To summarise, we have:
340- ``:::`` to convert an effect to a labelled effect.
339- ``:::`` to convert an effect to a labelled effect.
342−- ``:-`` to convert an effectful operation to a labelled effectful
341+- ``:-`` to convert an effectful operation to a labelled effectful operation.
345- ``:=`` to initialise a resource for a labelled effect.
343- ``:=`` to initialise a resource for a labelled effect.
@@ -350,7 +348,7 @@ only for the situation where available effects are not updated):
350.. code-block:: idris
348.. code-block:: idris
352 (:::) : lbl -> EFFECT -> EFFECT
350 (:::) : lbl -> EFFECT -> EFFECT
353− (:-) : (l : lbl) -> { [x] } Eff a -> { [l ::: x] } Eff a
351+ (:-) : (l : lbl) -> Eff a [x] -> Eff a [l ::: x]
354 (:=) : (l : lbl) -> res -> LRes l res
352 (:=) : (l : lbl) -> res -> LRes l res
356Here, ``LRes`` is simply the resource type associated with a labelled
354Here, ``LRes`` is simply the resource type associated with a labelled
@@ -367,7 +365,7 @@ immediately. The following program returns the length of the
368.. code-block:: idris
366.. code-block:: idris
370− stateLength : { [STATE String] } Eff Nat
368+ stateLength : Eff Nat [STATE String]
371 stateLength = do x <- get
369 stateLength = do x <- get
372 pure (length x)
370 pure (length x)
@@ -377,7 +375,7 @@ this. The above program can be written instead as:
378.. code-block:: idris
376.. code-block:: idris
380− stateLength : { [STATE String] } Eff Nat
378+ stateLength : Eff Nat [STATE String]
381 stateLength = pure (length !get)
379 stateLength = pure (length !get)
383The notation ``!expr`` means that the expression ``expr`` should be
381The notation ``!expr`` means that the expression ``expr`` should be
@@ -386,7 +384,7 @@ evaluated and then implicitly bound. Conceptually, we can think of
387.. code-block:: idris
385.. code-block:: idris
389− (!) : { xs } Eff a -> a
387+ (!) : Eff a xs -> a
391Note, however, that it is not really a function, merely syntax! In
389Note, however, that it is not really a function, merely syntax! In
392practice, a subexpression ``!expr`` will lift ``expr`` as high as
390practice, a subexpression ``!expr`` will lift ``expr`` as high as
@@ -411,22 +409,22 @@ is lifted to:
411 g' <- g y' x'
409 g' <- g y' x'
414−Syntactic Sugar and ``Eff``
412+The Type ``Eff``
415−===========================
413+================
417−By now, you may be wondering about the syntax we are using for
415+Underneath, ``Eff`` is an overloaded function which translates to an
418−``Eff``, because it doesn’t look like a normal type! (If not, you may
416+underlying type ``EffM``:
419−safely skip this section and return to it later.) In fact, the type of
420−``Eff`` is the following:
422.. code-block:: idris
418.. code-block:: idris
424− Eff : (x : Type) ->
420+ EffM : (m : Type -> Type) -> (t : Type)
425− List EFFECT -> (x -> List EFFECT) -> Type
422+ -> (t -> List EFFECT) -> Type
427This is more general than the types we have been writing so far. It is
424This is more general than the types we have been writing so far. It is
425+parameterised over an underlying computation context ``m``, a
428−parameterised over a result type ``x``, as we have already seen, but
426+result type ``t`` as we have already seen, as well as a ``List EFFECT`` and a
429−also a ``List EFFECT`` and a function type ``x -> List EFFECT``.
427+function type ``t -> List EFFECT``.
431These additional parameters are the list of *input* effects, and a
429These additional parameters are the list of *input* effects, and a
432list of *output* effects, computed from the result of an effectful
430list of *output* effects, computed from the result of an effectful
@@ -435,8 +433,7 @@ of effects available! This is a particularly powerful idea, and we
435will see its consequences in more detail later. Some examples of
433will see its consequences in more detail later. Some examples of
436operations which can change the set of available effects are:
434operations which can change the set of available effects are:
438−- Updating a state containing a dependent type (for example adding an
436+- Updating a state containing a dependent type (for example adding an element to a vector).
439− element to a vector).
441- Opening a file for reading is an effect, but whether the file really
438- Opening a file for reading is an effect, but whether the file really
442 *is* open afterwards depends on whether the file was successfully
439 *is* open afterwards depends on whether the file was successfully
@@ -445,19 +442,25 @@ operations which can change the set of available effects are:
445- Closing a file means that reading from the file should no longer be
442- Closing a file means that reading from the file should no longer be
446 possible.
443 possible.
448−While powerful, this can make uses of the ``Eff`` type hard to read.
445+While powerful, this can make uses of the ``EffM`` type hard to read.
449−Therefore, the library provides syntactic sugar which is translated
446+Therefore the library provides an overloaded function ``Eff``
450−such that:
447+There are the following three versions:
452.. code-block:: idris
449.. code-block:: idris
454− { xs } Eff a
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
456−is expanded to
457+So far, we have used only the first version, ``SimpleEff.Eff``, which
458+is defined as follows:
458.. code-block:: idris
460.. code-block:: idris
460− Eff a xs (\_ => xs)
462+ Eff : (x : Type) -> (es : List EFFECT) -> Type
463+ Eff x es = {m : Type -> Type} -> EffM m x es (\v => es)
462i.e. the set of effects remains the same on output. This suffices for
465i.e. the set of effects remains the same on output. This suffices for
463the ``STATE`` example we have seen so far, and for many useful
466the ``STATE`` example we have seen so far, and for many useful
@@ -467,19 +470,19 @@ with the expanded type:
467.. code-block:: idris
470.. code-block:: idris
469 treeTagAux : BTree a ->
472 treeTagAux : BTree a ->
470− Eff (BTree (Int, a)) [STATE Int] (\x => [STATE Int])
473+ EffM m (BTree (Int, a)) [STATE Int] (\x => [STATE Int])
472Later, we will see programs which update effects:
475Later, we will see programs which update effects:
474.. code-block:: idris
477.. code-block:: idris
476− { xs ==> xs' } Eff a
479+ Eff a xs xs'
478which is expanded to
481which is expanded to
480.. code-block:: idris
483.. code-block:: idris
482− Eff a xs (\_ => xs')
485+ EffM m a xs (\_ => xs')
484i.e. the set of effects is updated to ``xs’`` (think of a transition
487i.e. the set of effects is updated to ``xs’`` (think of a transition
485in a state machine). There is, for example, a version of ``put`` which
488in a state machine). There is, for example, a version of ``put`` which
@@ -487,22 +490,27 @@ updates the type of the state:
488.. code-block:: idris
491.. code-block:: idris
490− putM : y -> { [STATE x] ==> [STATE y] } Eff ()
493+ putM : y -> Eff () [STATE x] [STATE y]
492Also, we have:
495Also, we have:
494.. code-block:: idris
497.. code-block:: idris
496− { xs ==> {res} xs' } Eff a
499+ Eff t xs (\res => xs')
498which is expanded to
501which is expanded to
500.. code-block:: idris
503.. code-block:: idris
502− Eff a xs (\res => xs')
505+ EffM m t xs (\res => xs')
504i.e. the set of effects is updated according to the result of the
507i.e. the set of effects is updated according to the result of the
505−operation ``res``.
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.
507.. [1] The earlier paper [3]_ describes the essential implementation
515.. [1] The earlier paper [3]_ describes the essential implementation
508 details, although the library presented there is an earlier version
516 details, although the library presented there is an earlier version
@@ -513,7 +521,9 @@ operation ``res``.
513.. [3] Edwin Brady. 2013. Programming and reasoning with algebraic
521.. [3] Edwin Brady. 2013. Programming and reasoning with algebraic
514 effects and dependent types. SIGPLAN Not. 48, 9 (September
522 effects and dependent types. SIGPLAN Not. 48, 9 (September
515 2013), 133-144. DOI=10.1145/2544174.2500581
523 2013), 133-144. DOI=10.1145/2544174.2500581
516− http://doi.acm.org/10.1145/2544174.2500581
524+ http://dl.acm.org/citation.cfm?doid=2544174.2500581
518.. |image| image:: ../image/effects-tree.png
528.. |image| image:: ../image/effects-tree.png
519 :width: 500px
529 :width: 500px
docs/effects/summary.rst+41−42
@@ -20,13 +20,13 @@ EXCEPTION
21 EXCEPTION : Type -> EFFECT
21 EXCEPTION : Type -> EFFECT
23− raise : a -> { [EXCEPTION a ] } Eff m b
23+ raise : a -> Eff b [EXCEPTION a]
25− instance Handler (Exception a) Maybe
25+ Handler (Exception a) Maybe where { ... }
26− instance Handler (Exception a) List
26+ Handler (Exception a) List where { ... }
27− instance Handler (Exception a) (Either a)
27+ Handler (Exception a) (Either a) where { ... }
28− instance Handler (Exception a) (IOExcept a)
28+ Handler (Exception a) (IOExcept a) where { ... }
29− instance Show a => Handler (Exception a) IO
29+ Show a => Handler (Exception a) IO where { ... }
@@ -42,20 +42,19 @@ FILE\_IO
43 data OpenFile : Mode -> Type
43 data OpenFile : Mode -> Type
45− open : Handler FileIO e => String -> (m : Mode) ->
45+ open : (fname : String)
46− { [FILE_IO ()] ==>
46+ -> (m : Mode)
47− {ok} [FILE_IO (if ok then OpenFile m else ())] } Eff e Bool
47+ -> Eff Bool [FILE_IO ()]
48− close : Handler FileIO e =>
48+ (\res => [FILE_IO (case res of
49− { [FILE_IO (OpenFile m)] ==> [FILE_IO ()] } Eff e ()
51+ close : Eff () [FILE_IO (OpenFile m)] [FILE_IO ()]
51− readLine : Handler FileIO e =>
52− { [FILE_IO (OpenFile Read)] } Eff e String
53+ readLine : Eff String [FILE_IO (OpenFile Read)]
53− writeLine : Handler FileIO e => String ->
54− { [FILE_IO (OpenFile Write)] } Eff e ()
54+ writeLine : String -> Eff () [FILE_IO (OpenFile Write)]
55− eof : Handler FileIO e =>
55+ eof : Eff Bool [FILE_IO (OpenFile Read)]
56− { [FILE_IO (OpenFile Read)] } Eff e Bool
58− instance Handler FileIO IO
57+ Handler FileIO IO where { ... }
@@ -70,11 +69,11 @@ RND
71 RND : EFFECT
70 RND : EFFECT
73− srand : Integer -> { [RND] } Eff m ()
72+ srand : Integer -> Eff () [RND]
74− rndInt : Integer -> Integer -> { [RND] } Eff m Integer
73+ rndInt : Integer -> Integer -> Eff Integer [RND]
75− rndFin : (k : Nat) -> { [RND] } Eff m (Fin (S k))
74+ rndFin : (k : Nat) -> Eff (Fin (S k)) [RND]
77− instance Handler Random m
76+ Handler Random m where { ... }
@@ -87,10 +86,10 @@ SELECT
88 SELECT : EFFECT
87 SELECT : EFFECT
90− select : List a -> { [SELECT] } Eff m a
89+ select : List a -> Eff a [SELECT]
92− instance Handler Selection Maybe
91+ Handler Selection Maybe where { ... }
93− instance Handler Selection List
92+ Handler Selection List where { ... }
@@ -103,12 +102,12 @@ STATE
104 STATE : Type -> EFFECT
103 STATE : Type -> EFFECT
106− get : { [STATE x] } Eff m x
105+ get : Eff x [STATE x]
107− put : x -> { [STATE x] } Eff m ()
106+ put : x -> Eff () [STATE x]
108− putM : y -> { [STATE x] ==> [STATE y] } Eff m ()
107+ putM : y -> Eff () [STATE x] [STATE y]
109− update : (x -> x) -> { [STATE x] } Eff m ()
108+ update : (x -> x) -> Eff () [STATE x]
111− instance Handler State m
110+ Handler State m where { ... }
@@ -122,15 +121,15 @@ STDIO
123 STDIO : EFFECT
122 STDIO : EFFECT
125− putChar : Handler StdIO m => Char -> { [STDIO] } Eff m ()
124+ putChar : Char -> Eff () [STDIO]
126− putStr : Handler StdIO m => String -> { [STDIO] } Eff m ()
125+ putStr : String -> Eff () [STDIO]
127− putStrLn : Handler StdIO m => String -> { [STDIO] } Eff m ()
126+ putStrLn : String -> Eff () [STDIO]
129− getStr : Handler StdIO m => { [STDIO] } Eff m String
128+ getStr : Eff String [STDIO]
130− getChar : Handler StdIO m => { [STDIO] } Eff m Char
129+ getChar : Eff Char [STDIO]
132− instance Handler StdIO IO
131+ Handler StdIO IO where { ... }
133− instance Handler StdIO (IOExcept a)
132+ Handler StdIO (IOExcept a) where { ... }
@@ -145,9 +144,9 @@ SYSTEM
146 SYSTEM : EFFECT
145 SYSTEM : EFFECT
148− getArgs : Handler System e => { [SYSTEM] } Eff e (List String)
147+ getArgs : Eff (List String) [SYSTEM]
149− time : Handler System e => { [SYSTEM] } Eff e Int
148+ time : Eff Int [SYSTEM]
150− getEnv : Handler System e => String -> { [SYSTEM] } Eff e (Maybe String)
149+ getEnv : String -> Eff (Maybe String) [SYSTEM]
152− instance Handler System IO
151+ Handler System IO where { ... }
153− instance Handler System (IOExcept a)
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
@@ -5,13 +5,18 @@ Frequently Asked Questions
5What are the differences between Agda and Idris?
5What are the differences between Agda and Idris?
6================================================
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.
8−The main difference is that Idris has been designed from the start to support
10+However, Idris has been designed from the start to emphasise general purpose
9−verified systems programming through easy interoperability with C and high
10−level language constructs to support domain specific language implementation.
11−Idris emphasises general-purpose programming, rather than theorem proving, and
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
12−as such includes higher level programming constructs such as type classes and
14+programming constructs such as interfaces (similar to type classes) and do notation.
13−do notation. Idris also supports tactic based theorem proving, and has a
15+
14−lightweight Hugs/GHCI style interface.
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.
16Is Idris production ready?
21Is Idris production ready?
17==========================
22==========================
@@ -28,6 +33,31 @@ for use in production would be very welcome - this includes (but is not
28limited to) extra library support, polishing the run-time system (and ensuring
33limited to) extra library support, polishing the run-time system (and ensuring
29it is robust), providing and maintaining a JVM back end, etc.
34it 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.
31Why does Idris use eager evaluation rather than lazy?
61Why does Idris use eager evaluation rather than lazy?
32=====================================================
62=====================================================
@@ -56,6 +86,7 @@ Here, it is clear from the type that ``thing_val`` is guaranteed to be a
56concrete ``Int``, whereas ``thing_comp`` is a computation which will produce an
86concrete ``Int``, whereas ``thing_comp`` is a computation which will produce an
59How can I make lazy control structures?
90How can I make lazy control structures?
60=======================================
91=======================================
@@ -70,9 +101,10 @@ Booleans is defined as follows in the library:
70 ifThenElse True t e = t
101 ifThenElse True t e = t
71 ifThenElse False t e = e
102 ifThenElse False t e = e
73−The type ``Lazy a`` for ``t`` and ``f`` indicates that those arguments will
104+The type ``Lazy a`` for ``t`` and ``e`` indicates that those arguments will
74only be evaluated if they are used, that is, they are evaluated lazily.
105only be evaluated if they are used, that is, they are evaluated lazily.
76Evaluation at the REPL doesn't behave as I expect. What's going on?
108Evaluation at the REPL doesn't behave as I expect. What's going on?
77===================================================================
109===================================================================
@@ -99,37 +131,124 @@ the difference between:
99 Idris> \n, m => n + (S m)
131 Idris> \n, m => n + (S m)
100 \n => \m => plus n (S m) : Nat -> Nat -> Nat
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``
102When will Idris be self-hosting?
215When will Idris be self-hosting?
103================================
216================================
105−It’s not a priority, though not a bad idea in the long run. It would be a
218+It’s not a priority, though not a bad idea in the long run. It would
106−worthwhile effort in the short term to implement libraries to support
219+be a worthwhile effort in the short term to implement libraries in
107−self-hosting, such as a good parsing library.
220+Idris to support self-hosting, such as argument parsing and a
221+POSIX-compliant library for system interaction.
109−Does Idris have Universe Polymorphism? What is the type of ``Type``?
223+Does Idris have universe polymorphism? What is the type of ``Type``?
110====================================================================
224====================================================================
112−Rather than Universe polymorphism, Idris has a cumulative hierarchy of
226+Rather than universe polymorphism, Idris has a cumulative hierarchy of
113universes; ``Type : Type 1``, ``Type 1 : Type 2``, etc.
227universes; ``Type : Type 1``, ``Type 1 : Type 2``, etc.
114−Cumulativity means that if ``x : Type n`` then also ``x : Type m``,
228+Cumulativity means that if ``x : Type n`` and ``n <= m``, then
115−provided that ``n <= m``.
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
117−Why does Idris use ``Float`` and ``Double`` instead of ``Float32`` and ``Float64``?
235+Why does Idris use ``Double`` instead of ``Float64``?
118−===================================================================================
236+=====================================================
120Historically the C language and many other languages have used the
238Historically the C language and many other languages have used the
121names ``Float`` and ``Double`` to represent floating point numbers of
239names ``Float`` and ``Double`` to represent floating point numbers of
122−size 32 and 64 respectivly. Newer languages such as Rust and Julia
240+size 32 and 64 respectively. Newer languages such as Rust and Julia
123−have begun to follow the naming scheme described in `IEE Standard for
241+have begun to follow the naming scheme described in `IEEE Standard for
124Floating-Point Arithmetic (IEEE 754)
242Floating-Point Arithmetic (IEEE 754)
125−<http://en.wikipedia.org/wiki/IEEE_floating_point>`_. This describes
243+<https://en.wikipedia.org/wiki/IEEE_floating_point>`_. This describes
126single and double precision numbers as ``Float32`` and ``Float64``;
244single and double precision numbers as ``Float32`` and ``Float64``;
127the size is described in the type name.
245the size is described in the type name.
129Due to developer familiarity with the older naming convention, and
247Due to developer familiarity with the older naming convention, and
130choice by the developers of Idris, Idris uses the C style convention.
248choice by the developers of Idris, Idris uses the C style convention.
131−That is, the names ``Float`` and ``Double`` are used to describe
249+That is, the name ``Double`` is used to describe double precision
132−single and double precision numbers.
250+numbers, and Idris does not support 32 bit floats at present.
134What is -ffreestanding?
253What is -ffreestanding?
135=======================
254=======================
@@ -140,22 +259,71 @@ where the install directory is unknown at build time. When passing this
140flag, the IDRIS_LIB_DIR environment variable needs to be set to the path
259flag, the IDRIS_LIB_DIR environment variable needs to be set to the path
141where the Idris libs reside relative to the idris executable. The
260where the Idris libs reside relative to the idris executable. The
142IDRIS_TOOLCHAIN_DIR environment variable is optional, if that is set,
261IDRIS_TOOLCHAIN_DIR environment variable is optional, if that is set,
143−Idris will use that path to find the C compiler.
262+Idris will use that path to find the C compiler. For example:
147− IDRIS_LIB_DIR="./libs" IDRIS_TOOLCHAIN_DIR="./mingw/bin" CABALFLAGS="-fffi -ffreestanding -frelease" make
266+ IDRIS_LIB_DIR="./libs" \
267+ IDRIS_TOOLCHAIN_DIR="./mingw/bin" \
268+ CABALFLAGS="-fffi -ffreestanding -frelease" \
149−What does the name ‘Idris’ mean?
272+What does the name “Idris” mean?
150================================
273================================
152British people of a certain age may be familiar with this
275British people of a certain age may be familiar with this
153`singing dragon <https://www.youtube.com/watch?v=G5ZMNyscPcg>`_. If
276`singing dragon <https://www.youtube.com/watch?v=G5ZMNyscPcg>`_. If
154that doesn’t help, maybe you can invent a suitable acronym :-) .
277that 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/>`_ .
156Where can I find more answers?
324Where can I find more answers?
157==============================
325==============================
159There is an `Unofficial FAQ
327There is an `Unofficial FAQ
160<https://github.com/idris-lang/Idris-dev/wiki/Unofficial-FAQ>`_ on the wiki on
328<https://github.com/idris-lang/Idris-dev/wiki/Unofficial-FAQ>`_ on the wiki on
161−github which answers more technical questions and may be updated more often.
329+GitHub which answers more technical questions and may be updated more often.
docs/guides/index.rst+2−1
@@ -12,10 +12,11 @@ Tutorials submitted by community members.
12 Idris Community* has waived all copyright and related or neighboring
12 Idris Community* has waived all copyright and related or neighboring
13 rights to Documentation for Idris.
13 rights to Documentation for Idris.
15− More information concerning the CC0 can be found online at: http://creativecommons.org/publicdomain/zero/1.0/
15+ More information concerning the CC0 can be found online at: https://creativecommons.org/publicdomain/zero/1.0/
18.. toctree::
18.. toctree::
19 :maxdepth: 1
19 :maxdepth: 1
21 type-providers-ffi
21 type-providers-ffi
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.rst+37−81
@@ -3,7 +3,7 @@ Type Providers in Idris
3***********************
3***********************
5`Type providers in Idris
5`Type providers in Idris
6−<http://www.itu.dk/people/drc/pubs/dependent-type-providers.pdf>`__
6+<https://www.davidchristiansen.dk/pubs/dependent-type-providers.pdf>`__
7are simple enough, but there are a few caveats to using them that it
7are simple enough, but there are a few caveats to using them that it
8would be worthwhile to go through the basic steps. We also go over
8would be worthwhile to go through the basic steps. We also go over
9foreign functions, because these will often be used with type
9foreign functions, because these will often be used with type
@@ -53,8 +53,8 @@ actions. Let's write a simple one now:
53 putStrLn "I'm sorry, I don't know how big size_t is. Can you tell me, in bytes?"
53 putStrLn "I'm sorry, I don't know how big size_t is. Can you tell me, in bytes?"
54 resp <- getLine
54 resp <- getLine
55 case readInt resp of
55 case readInt resp of
56− Just sizeTSize => return (Provide sizeTSize)
56+ Just sizeTSize => pure (Provide sizeTSize)
57− Nothing => return (Error "I'm sorry, I don't understand.")
57+ Nothing => pure (Error "I'm sorry, I don't understand.")
58 -- the readInt function is left as an exercise
58 -- the readInt function is left as an exercise
60We assume that whoever's compiling the library knows the size of
60We assume that whoever's compiling the library knows the size of
@@ -115,75 +115,19 @@ So now we can get the size of ``size_t`` as long as we're in C code.
115We'd like to be able to use this from Idris. Can we do this? It turns
115We'd like to be able to use this from Idris. Can we do this? It turns
116out we can.
116out we can.
118−``mkForeign``
118+``foreign``
119-------------
119-------------
121−With mkForeign, we can turn a C function into an IO action. It works
121+With foreign, we can turn a C function into an IO action. It works
122like this:
122like this:
124.. code-block:: idris
124.. code-block:: idris
126 getSizeT : IO Int
126 getSizeT : IO Int
127− getSizeT = mkForeign (FFun "sizeof_size_t" [] FInt)
127+ getSizeT = foreign FFI_C "sizeof_size_t" (IO Int)
129−Pretty simple. ``mkForeign`` takes a specification of what function it
129+Pretty simple. ``foreign`` takes a specification of what function it
130−needs to call, and we construct this specification with ``FFun``. And
130+needs to call and that function's return type.
131−``FFun`` just takes a name, a list of argument types (we have none),
134−One thing you might want to note: the return type we've specified is
135−``FInt``, not ``Int``. That's because ``Int`` is an idris type and C
136−functions don't return idris types. ``FInt`` is not an idris type, but
137−is just the representation of the type of a C int. It tells the
138−compiler "Treat the return value of this C function like it's a C int,
139−and when you pass it back into Idris, convert it to an Idris int."
144−First and foremost: ``mkForeign`` is not actually a function. It is
145−treated specially by the compiler, and there are certain rules you
146−need to follow when using it.
148−- Rule 1: the name string must be a literal or constant
152−.. code-block:: idris
154− intIntToInt : String -> Int -> Int -> IO Int
155− intIntToInt name = mkForeign (FFun name [FInt, FInt] FInt)
157−You'll just have to bite the bullet and write out the whole
158−``mkForeign`` and ``FFun`` expression each time.
160−- Rule 2: the "call" to ``mkForeign`` must be fully applied
162−This just means that every argument appearing in the list of argument
163−types must be applied wherever you write ``mkForeign``. The arguments
164−don't have to be literals or even known at compile time; they just
165−have to be there. For example, if we have ``strlen : String -> IO
166−Int``, then this is fine:
168−.. code-block:: idris
170− strlen str = mkForeign (FFun "strlen" [FString] FInt) str
172−but this is not fine:
174−.. code-block:: idris
176− strlen = mkForeign (FFun "strlen" [FString] FInt)
178−Note that this only applies to places where you literally typed
179−``mkForeign``. Once you've defined it, ``strlen`` is just a normal
180−function returning an IO action, and it doesn't need to be fully
181−applied. This is okay:
183−.. code-block:: idris
186− lengths = mapM strlen listOfStrings
188Running foreign functions
132Running foreign functions
189-------------------------
133-------------------------
@@ -242,6 +186,8 @@ First, let's write a C file containing functions that we'll bind to.
242.. code-block:: c
186.. code-block:: c
244 /* stattypes.c */
188 /* stattypes.c */
189+ #include <sys/stat.h>
245 int sizeof_dev_t() { return sizeof(dev_t); }
191 int sizeof_dev_t() { return sizeof(dev_t); }
246 int sizeof_ino_t() { return sizeof(ino_t); }
192 int sizeof_ino_t() { return sizeof(ino_t); }
247 /* lots more functions like this */
193 /* lots more functions like this */
@@ -254,22 +200,34 @@ Next, an Idris file to define our providers:
254 module Providers
200 module Providers
256 %dynamic "./stattypes.so"
202 %dynamic "./stattypes.so"
258 sizeOfDevT : IO Int
205 sizeOfDevT : IO Int
259− sizeOfDevT = mkForeign (FFun "sizeof_dev_t" [] FInt)
206+ sizeOfDevT = foreign FFI_C "sizeof_dev_t" (IO Int)
260 {- lots of similar functions -}
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"
262− -- now we have an integer, but we want a Provider FTy
220+ -- Now we have an integer, but we want a Provider BitWidth.
263− -- since our sizeOf* functions are ordinary IO actions, we
221+ -- Since our sizeOf* functions are ordinary IO actions, we
264 -- can just map over them.
222 -- can just map over them.
265− bytesToType : Int -> Provider FTy
223+ bytesToType : Int -> Provider BitWidth
266− bytesToType 1 = Provide (FIntT IT8) -- "8 bit foreign integer"
224+ bytesToType 1 = Provide B8 -- "8 bit value"
267− bytesToType 2 = Provide (FIntT IT16)
225+ bytesToType 2 = Provide B16
268− bytesToType 4 = Provide (FIntT IT32)
226+ bytesToType 4 = Provide B32
269− bytesToType 8 = Provide (FIntT IT64)
227+ bytesToType 8 = Provide B64
270− bytesToType _ = Error "Unrecognized integral type."
228+ bytesToType _ = Error "Unrecognised integral type."
272− getDevT : IO (Provider FTy)
230+ getDevT : IO (Provider BitWidth)
273 getDevT = map bytesToType sizeOfDevT
231 getDevT = map bytesToType sizeOfDevT
274 {- lots of similar functions -}
232 {- lots of similar functions -}
@@ -282,10 +240,8 @@ providers:
282 module Main
240 module Main
283 import Providers
241 import Providers
284 %language TypeProviders
242 %language TypeProviders
285− %provide (FDevT : FTy) with getDevT
243+ %provide (DevTBitWidth : BitWidth) with getDevT
287− -- interpFTy translates a foreign type to the corresponding idris type
289− DevT = interpFTy FDevT -- on most systems, DevT = Bits64
291− -- We can now use DevT in our program and FDevT in our FFun expressions!
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/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
@@ -0,0 +1,339 @@
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="plusReducesProof.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: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:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;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:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;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:#0000ff;stroke-width:1pt;stroke-opacity:1;fill:#0000ff;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="397.18872"
90+ inkscape:document-units="px"
91+ inkscape:current-layer="layer1"
93+ inkscape:window-width="1110"
94+ inkscape:window-height="1011"
95+ inkscape:window-x="-4"
96+ inkscape:window-y="0"
97+ inkscape:window-maximized="0" />
103+ <dc:format>image/svg+xml</dc:format>
105+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
106+ <dc:title></dc:title>
111+ inkscape:label="Layer 1"
112+ inkscape:groupmode="layer"
115+ xml:space="preserve"
116+ 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"
120+ sodipodi:linespacing="125%"><tspan
121+ sodipodi:role="line"
124+ y="225.36221">assumptions</tspan><tspan
125+ sodipodi:role="line"
128+ id="tspan4140">(context)</tspan></text>
130+ sodipodi:linespacing="125%"
134+ 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;"
135+ xml:space="preserve"><tspan
139+ sodipodi:role="line">goal</tspan></text>
141+ xml:space="preserve"
142+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
146+ sodipodi:linespacing="125%"><tspan
147+ sodipodi:role="line"
150+ id="tspan4152">(k : Nat) -> (k = plus k 0) -> S k = S (plus k 0)</tspan></text>
152+ style="fill:none;fill-rule:evenodd;stroke:#ff0000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
153+ d="m 241,262.3622 428,-1"
155+ inkscape:connector-curvature="0" />
157+ inkscape:connector-curvature="0"
159+ d="m 241,308.3622 428,-1"
160+ 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" />
162+ sodipodi:linespacing="125%"
166+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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;"
167+ xml:space="preserve"><tspan
171+ sodipodi:role="line">intro `{{k}}</tspan></text>
173+ sodipodi:linespacing="125%"
177+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
178+ xml:space="preserve"><tspan
182+ sodipodi:role="line">(k = plus k 0) -> S k = S (plus k 0)</tspan></text>
184+ xml:space="preserve"
185+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
189+ sodipodi:linespacing="125%"><tspan
190+ sodipodi:role="line"
193+ id="tspan4172">k : Nat</tspan></text>
195+ 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(#Arrow1Mend)"
196+ d="m 441,294.3622 -73,30"
198+ inkscape:connector-curvature="0"
199+ sodipodi:nodetypes="cc" />
201+ 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"
202+ d="m 241,352.3622 428,-1"
204+ inkscape:connector-curvature="0" />
206+ xml:space="preserve"
207+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
211+ sodipodi:linespacing="125%"><tspan
212+ sodipodi:role="line"
215+ id="tspan5138">intro `{{ih}}</tspan></text>
217+ xml:space="preserve"
218+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
222+ sodipodi:linespacing="125%"><tspan
223+ sodipodi:role="line"
226+ id="tspan5142">S k = S (plus k 0)</tspan></text>
228+ sodipodi:linespacing="125%"
232+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
233+ xml:space="preserve"><tspan
237+ sodipodi:role="line">k : Nat</tspan></text>
239+ sodipodi:linespacing="125%"
243+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
244+ xml:space="preserve"><tspan
248+ sodipodi:role="line">ih : k = plus k 0</tspan></text>
250+ inkscape:connector-curvature="0"
252+ d="m 242,404.3622 428,-1"
253+ 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" />
255+ sodipodi:linespacing="125%"
259+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
260+ xml:space="preserve"><tspan
264+ sodipodi:role="line">rewriteWith (Var `{{ih}})</tspan></text>
266+ sodipodi:linespacing="125%"
270+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
271+ xml:space="preserve"><tspan
275+ sodipodi:role="line">S k = S k </tspan></text>
277+ xml:space="preserve"
278+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
282+ sodipodi:linespacing="125%"><tspan
283+ sodipodi:role="line"
286+ id="tspan5740">k : Nat</tspan></text>
288+ 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(#marker5748)"
289+ d="m 610,379.3622 1,29"
291+ inkscape:connector-curvature="0"
292+ sodipodi:nodetypes="cc" />
294+ xml:space="preserve"
295+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
299+ sodipodi:linespacing="125%"><tspan
300+ sodipodi:role="line"
303+ id="tspan5746">ih : k = plus k 0</tspan></text>
305+ inkscape:connector-curvature="0"
307+ d="m 418,460.3622 -2,-199"
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" />
311+ sodipodi:nodetypes="cc"
312+ inkscape:connector-curvature="0"
314+ d="m 519,339.3622 -107,44"
315+ 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(#marker5154)" />
317+ style="fill:none;fill-rule:evenodd;stroke:#0000ff;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:12, 2;stroke-dashoffset:0;stroke-opacity:1"
318+ d="m 609,391.3622 -197,49"
320+ inkscape:connector-curvature="0"
321+ sodipodi:nodetypes="cc" />
323+ 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"
324+ d="m 242,458.3622 428,-1"
326+ inkscape:connector-curvature="0" />
328+ xml:space="preserve"
329+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12.5px;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"
333+ sodipodi:linespacing="125%"><tspan
334+ sodipodi:role="line"
337+ id="tspan7312">reflexivity</tspan></text>
docs/image/recogniser.pngnew file
Binary file not shown.
docs/image/recogniser.svgnew file+477
@@ -0,0 +1,477 @@
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="recogniser.svg">
24+ bordercolor="#666666"
26+ inkscape:pageopacity="0.0"
27+ inkscape:pageshadow="2"
29+ inkscape:cx="384.45994"
31+ inkscape:document-units="mm"
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+ style="opacity:1;vector-effect:none;fill:none;fill-opacity:0.97596154;fill-rule:evenodd;stroke:#0000ff;stroke-width:0.70599997;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
63+ inkscape:export-xdpi="61.120499"
64+ inkscape:export-ydpi="61.120499" />
67+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:5.64444447px;line-height:1.25;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:0.26458332"
71+ inkscape:export-xdpi="61.120499"
72+ inkscape:export-ydpi="61.120499"><tspan
77+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:5.64444447px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#0000ff;stroke-width:0.26458332">Text.Lexer.Core</tspan></text>
82+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:1.25;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:0.26458332"
84+ inkscape:export-xdpi="61.120499"
85+ inkscape:export-ydpi="61.120499"><tspan
86+ 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';stroke-width:0.26458332"
90+ sodipodi:role="line">data Recognise : (consumes : Bool) -> Type where</tspan><tspan
91+ 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';stroke-width:0.26458332"
95+ id="tspan825"> Empty : Recognise False</tspan><tspan
96+ 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';stroke-width:0.26458332"
100+ id="tspan827"> Fail : Recognise c</tspan><tspan
101+ 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';stroke-width:0.26458332"
104+ sodipodi:role="line"
105+ id="tspan829"> Lookahead : (positive : Bool) -> Recognise c -> Recognise False</tspan><tspan
106+ 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';stroke-width:0.26458332"
109+ sodipodi:role="line"
110+ id="tspan831"> Pred : (Char -> Bool) -> Recognise True</tspan><tspan
111+ 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';stroke-width:0.26458332"
114+ sodipodi:role="line"
115+ id="tspan835"> SeqEat : Recognise True -> Inf (Recognise e) -> Recognise True</tspan><tspan
116+ 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';stroke-width:0.26458332"
119+ sodipodi:role="line"
120+ id="tspan837"> SeqEmpty : Recognise e1 -> Recognise e2 -> Recognise (e1 || e2)</tspan><tspan
121+ 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';stroke-width:0.26458332"
124+ sodipodi:role="line"
125+ id="tspan839"> Alt : Recognise e1 -> Recognise e2 -> Recognise (e1 && e2)</tspan><tspan
126+ 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';stroke-width:0.26458332"
129+ sodipodi:role="line"
130+ id="tspan841" /><tspan
131+ 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';stroke-width:0.26458332"
134+ sodipodi:role="line"
135+ id="tspan843">||| A token recogniser. Guaranteed to consume at least one character.</tspan><tspan
136+ 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';stroke-width:0.26458332"
139+ sodipodi:role="line"
140+ id="tspan845">public export</tspan><tspan
141+ 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';stroke-width:0.26458332"
144+ sodipodi:role="line"
145+ id="tspan847">Lexer : Type</tspan><tspan
146+ 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';stroke-width:0.26458332"
149+ sodipodi:role="line"
150+ id="tspan849">Lexer = Recognise True</tspan><tspan
151+ 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"
154+ sodipodi:role="line"
155+ id="tspan851" /></text>
157+ 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"
163+ inkscape:export-xdpi="61.120499"
164+ inkscape:export-ydpi="61.120499" />
171+ 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"
172+ inkscape:export-xdpi="61.120499"
173+ inkscape:export-ydpi="61.120499" />
175+ inkscape:export-ydpi="61.120499"
176+ inkscape:export-xdpi="61.120499"
180+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
181+ xml:space="preserve"><tspan
182+ 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:#ff0000;stroke-width:0.26458332"
185+ sodipodi:role="line"
186+ id="tspan908">(<+>) : Recognise c1 -> inf c1 (Recognise c2) -> </tspan><tspan
187+ 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:#ff0000;stroke-width:0.26458332"
190+ sodipodi:role="line"
191+ id="tspan929"> Recognise (c1 || c2)</tspan><tspan
192+ 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:#ff0000;stroke-width:0.26458332"
195+ sodipodi:role="line"
196+ id="tspan916">Sequence two recognisers. If either consumes a</tspan><tspan
197+ 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:#ff0000;stroke-width:0.26458332"
200+ sodipodi:role="line"
201+ id="tspan918">character, the sequence is guaranteed to</tspan><tspan
202+ 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:#ff0000;stroke-width:0.26458332"
205+ sodipodi:role="line"
206+ id="tspan935">consume a character</tspan><tspan
207+ 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:#ff0000;stroke-width:0.26458332"
210+ sodipodi:role="line"
211+ id="tspan912" /><tspan
212+ 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"
215+ sodipodi:role="line"
216+ id="tspan868" /></text>
218+ style="fill:none;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
219+ d="m 129.38124,100.41458 -7.9375,-2.910414"
221+ inkscape:connector-curvature="0"
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-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#ff0000;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"
236+ 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:#ff0000;stroke-width:0.26458332"
237+ id="tspan973">(<|>) : Recognise c1 -> Recognise c2 -></tspan><tspan
238+ sodipodi:role="line"
241+ 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:#ff0000;stroke-width:0.26458332"
242+ id="tspan975"> Recognise (c1 && c2)</tspan><tspan
243+ sodipodi:role="line"
246+ 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:#ff0000;stroke-width:0.26458332"
247+ id="tspan983">Alternative recognisers. If both consume, the</tspan><tspan
248+ sodipodi:role="line"
251+ 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:#ff0000;stroke-width:0.26458332"
252+ id="tspan985">combination is guaranteed to consumer a</tspan><tspan
253+ sodipodi:role="line"
256+ 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:#ff0000;stroke-width:0.26458332"
257+ id="tspan992">character.</tspan><tspan
258+ sodipodi:role="line"
261+ 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:#ff0000;stroke-width:0.26458332"
262+ id="tspan977" /><tspan
264+ sodipodi:role="line"
267+ 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:#ff0000;stroke-width:0.26458332" /><tspan
269+ sodipodi:role="line"
272+ 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" /></text>
274+ inkscape:connector-curvature="0"
276+ d="M 128.05833,126.87292 110.33125,110.46875"
277+ style="fill:none;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
278+ sodipodi:nodetypes="cc"
279+ inkscape:export-xdpi="61.120499"
280+ inkscape:export-ydpi="61.120499" />
282+ xml:space="preserve"
283+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
287+ inkscape:export-xdpi="61.120499"
288+ inkscape:export-ydpi="61.120499"><tspan
290+ sodipodi:role="line"
293+ 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:#ff0000;stroke-width:0.26458332">empty : Recognise False</tspan><tspan
294+ sodipodi:role="line"
297+ 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:#ff0000;stroke-width:0.26458332"
298+ id="tspan1087">Recognise no input (doesn't consume any input)</tspan><tspan
300+ sodipodi:role="line"
303+ 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:#ff0000;stroke-width:0.26458332" /><tspan
305+ sodipodi:role="line"
308+ 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" /></text>
310+ inkscape:export-ydpi="61.120499"
311+ inkscape:export-xdpi="61.120499"
315+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
316+ xml:space="preserve"><tspan
317+ 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:#ff0000;stroke-width:0.26458332"
320+ sodipodi:role="line"
321+ id="tspan1025">fail : Recognise c</tspan><tspan
322+ 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:#ff0000;stroke-width:0.26458332"
325+ sodipodi:role="line"
326+ id="tspan1089">A recogniser that always fails.</tspan><tspan
327+ 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:#ff0000;stroke-width:0.26458332"
330+ sodipodi:role="line"
331+ id="tspan1027" /><tspan
332+ 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"
335+ sodipodi:role="line"
336+ id="tspan1029" /></text>
338+ inkscape:export-ydpi="61.120499"
339+ inkscape:export-xdpi="61.120499"
343+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
344+ xml:space="preserve"><tspan
345+ 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:#ff0000;stroke-width:0.26458332"
348+ sodipodi:role="line"
349+ id="tspan1051">expect : Recognise c -> Recognise False</tspan><tspan
350+ 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:#ff0000;stroke-width:0.26458332"
353+ sodipodi:role="line"
354+ id="tspan1059">Positive lookahead. Never consumes input.</tspan><tspan
355+ 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:#ff0000;stroke-width:0.26458332"
358+ sodipodi:role="line"
359+ id="tspan1035" /><tspan
360+ 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"
363+ sodipodi:role="line"
364+ id="tspan1037" /></text>
366+ xml:space="preserve"
367+ style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:4.23333311px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
371+ inkscape:export-xdpi="61.120499"
372+ inkscape:export-ydpi="61.120499"><tspan
374+ sodipodi:role="line"
377+ 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:#ff0000;stroke-width:0.26458332">pred : (Char -> Bool) -> Lexer</tspan><tspan
378+ sodipodi:role="line"
381+ 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:#ff0000;stroke-width:0.26458332"
382+ id="tspan1085">Recognise a character that matches a predicate</tspan><tspan
384+ sodipodi:role="line"
387+ 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:#ff0000;stroke-width:0.26458332" /><tspan
389+ sodipodi:role="line"
392+ 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" /></text>
394+ 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"
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:4.23333311px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';letter-spacing:0px;word-spacing:0px;fill:#ff0000;fill-opacity:1;stroke:none;stroke-width:0.26458332"
408+ inkscape:export-xdpi="61.120499"
409+ inkscape:export-ydpi="61.120499"><tspan
411+ sodipodi:role="line"
414+ 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:#ff0000;stroke-width:0.26458332">reject : Recognise c -> Recognise False</tspan><tspan
415+ sodipodi:role="line"
418+ 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:#ff0000;stroke-width:0.26458332"
419+ id="tspan1073">Negative lookahead. Never consumes input.</tspan><tspan
420+ sodipodi:role="line"
423+ 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:#ff0000;stroke-width:0.26458332"
424+ id="tspan1075" /><tspan
426+ sodipodi:role="line"
429+ 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:#ff0000;stroke-width:0.26458332" /><tspan
431+ sodipodi:role="line"
434+ 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" /></text>
436+ sodipodi:nodetypes="cc"
437+ inkscape:connector-curvature="0"
439+ d="M 124.35416,89.83125 76.99375,94.858333"
440+ style="fill:none;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
441+ inkscape:export-xdpi="61.120499"
442+ inkscape:export-ydpi="61.120499" />
444+ style="fill:none;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
445+ d="M 123.82499,66.01875 112.97708,86.391666"
447+ inkscape:connector-curvature="0"
448+ sodipodi:nodetypes="cc"
449+ inkscape:export-xdpi="61.120499"
450+ inkscape:export-ydpi="61.120499" />
452+ sodipodi:nodetypes="cc"
453+ inkscape:connector-curvature="0"
455+ d="M 33.33749,59.139583 20.90208,76.337499"
456+ style="fill:none;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
457+ inkscape:export-xdpi="61.120499"
458+ inkscape:export-ydpi="61.120499" />
460+ style="fill:none;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
461+ d="M 113.77082,51.73125 42.068747,83.481249"
463+ inkscape:connector-curvature="0"
464+ sodipodi:nodetypes="cc"
465+ inkscape:export-xdpi="61.120499"
466+ inkscape:export-ydpi="61.120499" />
473+ 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"
474+ inkscape:export-xdpi="61.120499"
475+ inkscape:export-ydpi="61.120499" />
docs/image/solve.pngnew file
Binary file not shown.
docs/image/solve.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="solve.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" />
98+ 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+ 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"
106+ sodipodi:role="line">Prelude.Nat.Z </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';fill:#ff0000;stroke-width:0.26458332"
119+ sodipodi:role="line">solve</tspan></text>
121+ 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)"
122+ d="m 80.668481,106.30075 -0.0032,7.57492"
124+ inkscape:connector-curvature="0"
125+ sodipodi:nodetypes="cc"
126+ inkscape:export-xdpi="61.120499"
127+ inkscape:export-ydpi="61.120499" />
129+ inkscape:export-ydpi="61.120499"
130+ inkscape:export-xdpi="61.120499"
131+ xml:space="preserve"
132+ 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"
136+ sodipodi:role="line"
140+ 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>
142+ inkscape:export-ydpi="61.120499"
143+ inkscape:export-xdpi="61.120499"
144+ sodipodi:nodetypes="cc"
145+ inkscape:connector-curvature="0"
147+ d="m 57.649725,94.659084 -0.0032,5.458256"
148+ 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)" />
150+ inkscape:export-ydpi="61.120499"
151+ inkscape:export-xdpi="61.120499"
152+ xml:space="preserve"
153+ 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"
157+ sodipodi:role="line"
161+ 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} ≈ Prelude.Nat.Z . {hole}</tspan></text>
docs/image/tokenise.pngnew file
Binary file not shown.
docs/image/tokenise.svgnew file+740
@@ -0,0 +1,740 @@
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="tokenise.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"
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:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
48+ transform="scale(0.4) rotate(180) translate(10,0)" />
51+ inkscape:isstock="true"
52+ style="overflow:visible;"
57+ inkscape:stockid="Arrow1Mend"
58+ inkscape:collect="always">
60+ transform="scale(0.4) rotate(180) translate(10,0)"
61+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
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 "
66+ inkscape:stockid="Arrow1Mend"
71+ style="overflow:visible;"
72+ inkscape:isstock="true"
73+ inkscape:collect="always">
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 "
77+ style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
78+ transform="scale(0.4) rotate(180) translate(10,0)" />
84+ bordercolor="#666666"
86+ inkscape:pageopacity="0.0"
87+ inkscape:pageshadow="2"
89+ inkscape:cx="497.48698"
91+ inkscape:document-units="mm"
92+ inkscape:current-layer="layer1"
94+ inkscape:window-width="1920"
95+ inkscape:window-height="1015"
96+ inkscape:window-x="0"
97+ inkscape:window-y="0"
98+ inkscape:window-maximized="1" />
104+ <dc:format>image/svg+xml</dc:format>
106+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
107+ <dc:title></dc:title>
112+ inkscape:label="Layer 1"
113+ inkscape:groupmode="layer"
116+ 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"
122+ inkscape:export-xdpi="61.120499"
123+ inkscape:export-ydpi="61.120499" />
125+ xml:space="preserve"
126+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
130+ inkscape:export-xdpi="61.120499"
131+ inkscape:export-ydpi="61.120499"><tspan
132+ sodipodi:role="line"
136+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">i</tspan></text>
143+ 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"
144+ inkscape:export-xdpi="61.120499"
145+ inkscape:export-ydpi="61.120499" />
150+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
151+ xml:space="preserve"
152+ inkscape:export-xdpi="61.120499"
153+ inkscape:export-ydpi="61.120499"><tspan
154+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
158+ sodipodi:role="line">n</tspan></text>
165+ 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"
166+ inkscape:export-xdpi="61.120499"
167+ inkscape:export-ydpi="61.120499" />
172+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
173+ xml:space="preserve"
174+ inkscape:export-xdpi="61.120499"
175+ inkscape:export-ydpi="61.120499"><tspan
176+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
180+ sodipodi:role="line">p</tspan></text>
182+ 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"
188+ inkscape:export-xdpi="61.120499"
189+ inkscape:export-ydpi="61.120499" />
191+ xml:space="preserve"
192+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
196+ inkscape:export-xdpi="61.120499"
197+ inkscape:export-ydpi="61.120499"><tspan
198+ sodipodi:role="line"
202+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">u</tspan></text>
209+ 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"
210+ inkscape:export-xdpi="61.120499"
211+ inkscape:export-ydpi="61.120499" />
216+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
217+ xml:space="preserve"
218+ inkscape:export-xdpi="61.120499"
219+ inkscape:export-ydpi="61.120499"><tspan
220+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
224+ sodipodi:role="line">t</tspan></text>
226+ 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"
232+ inkscape:export-xdpi="61.120499"
233+ inkscape:export-ydpi="61.120499" />
235+ xml:space="preserve"
236+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
240+ sodipodi:role="line"
244+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none" /></text>
246+ 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"
252+ inkscape:export-xdpi="61.120499"
253+ inkscape:export-ydpi="61.120499" />
255+ xml:space="preserve"
256+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
260+ inkscape:export-xdpi="61.120499"
261+ inkscape:export-ydpi="61.120499"><tspan
262+ sodipodi:role="line"
266+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">s</tspan></text>
273+ 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"
274+ inkscape:export-xdpi="61.120499"
275+ inkscape:export-ydpi="61.120499" />
280+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
281+ xml:space="preserve"
282+ inkscape:export-xdpi="61.120499"
283+ inkscape:export-ydpi="61.120499"><tspan
284+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
288+ sodipodi:role="line">t</tspan></text>
295+ 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"
296+ inkscape:export-xdpi="61.120499"
297+ inkscape:export-ydpi="61.120499" />
302+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
303+ xml:space="preserve"
304+ inkscape:export-xdpi="61.120499"
305+ inkscape:export-ydpi="61.120499"><tspan
306+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
310+ sodipodi:role="line">r</tspan></text>
312+ 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"
318+ inkscape:export-xdpi="61.120499"
319+ inkscape:export-ydpi="61.120499" />
321+ xml:space="preserve"
322+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
326+ inkscape:export-xdpi="61.120499"
327+ inkscape:export-ydpi="61.120499"><tspan
328+ sodipodi:role="line"
332+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">i</tspan></text>
334+ 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"
340+ inkscape:export-xdpi="61.120499"
341+ inkscape:export-ydpi="61.120499" />
343+ xml:space="preserve"
344+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
348+ inkscape:export-xdpi="61.120499"
349+ inkscape:export-ydpi="61.120499"><tspan
350+ sodipodi:role="line"
354+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">n</tspan></text>
361+ 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"
362+ inkscape:export-xdpi="61.120499"
363+ inkscape:export-ydpi="61.120499" />
368+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
369+ xml:space="preserve"
370+ inkscape:export-xdpi="61.120499"
371+ inkscape:export-ydpi="61.120499"><tspan
372+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
376+ sodipodi:role="line">g</tspan></text>
378+ xml:space="preserve"
379+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
383+ inkscape:export-xdpi="61.120499"
384+ inkscape:export-ydpi="61.120499"><tspan
385+ sodipodi:role="line"
389+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none">:String</tspan></text>
396+ 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"
397+ inkscape:export-xdpi="61.120499"
398+ inkscape:export-ydpi="61.120499" />
403+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
404+ xml:space="preserve"><tspan
405+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
409+ sodipodi:role="line" /></text>
411+ 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"
417+ inkscape:export-xdpi="61.120499"
418+ inkscape:export-ydpi="61.120499" />
420+ xml:space="preserve"
421+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
425+ inkscape:export-xdpi="61.120499"
426+ inkscape:export-ydpi="61.120499"><tspan
427+ sodipodi:role="line"
431+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">1</tspan></text>
434+ transform="translate(-15.319488,0.319156)"
435+ inkscape:export-xdpi="61.120499"
436+ inkscape:export-ydpi="61.120499">
438+ 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"
445+ xml:space="preserve"
446+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
450+ sodipodi:role="line"
454+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">token</tspan></text>
461+ 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" />
466+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
467+ xml:space="preserve"><tspan
468+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
472+ sodipodi:role="line">line</tspan></text>
479+ 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" />
484+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
485+ xml:space="preserve"><tspan
486+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
490+ sodipodi:role="line">col</tspan></text>
496+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
497+ xml:space="preserve"
498+ inkscape:export-xdpi="61.120499"
499+ inkscape:export-ydpi="61.120499"><tspan
500+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
503+ sodipodi:role="line"
504+ id="tspan933">:(List (TokenData Token), Int, Int, String)</tspan></text>
507+ transform="translate(16.596112,0.319156)"
508+ inkscape:export-xdpi="61.120499"
509+ inkscape:export-ydpi="61.120499">
516+ 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" />
521+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
522+ xml:space="preserve"><tspan
523+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
527+ sodipodi:role="line">token</tspan></text>
529+ 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"
536+ xml:space="preserve"
537+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
541+ sodipodi:role="line"
545+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">line</tspan></text>
547+ 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"
554+ xml:space="preserve"
555+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
559+ sodipodi:role="line"
563+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">col</tspan></text>
566+ transform="translate(48.591501,0.319156)"
568+ inkscape:export-xdpi="61.120499"
569+ inkscape:export-ydpi="61.120499">
571+ 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"
578+ xml:space="preserve"
579+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
583+ sodipodi:role="line"
587+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">token</tspan></text>
594+ 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" />
599+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
600+ xml:space="preserve"><tspan
601+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
605+ sodipodi:role="line">line</tspan></text>
612+ 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" />
617+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
618+ xml:space="preserve"><tspan
619+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
623+ sodipodi:role="line">col</tspan></text>
626+ style="fill:none;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
627+ d="m 125.97308,68.549658 1.30238,0.0089 -0.0153,6.481345 h -1.30803"
629+ inkscape:connector-curvature="0"
630+ sodipodi:nodetypes="cccc"
631+ inkscape:export-xdpi="61.120499"
632+ inkscape:export-ydpi="61.120499" />
634+ sodipodi:nodetypes="cccc"
635+ inkscape:connector-curvature="0"
637+ d="m 32.561899,68.619523 -1.30238,0.0089 0.0153,6.481345 h 1.30803"
638+ style="fill:none;stroke:#ff0000;stroke-width:0.70555556;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
639+ inkscape:export-xdpi="61.120499"
640+ inkscape:export-ydpi="61.120499" />
642+ 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"
648+ inkscape:export-xdpi="61.120499"
649+ inkscape:export-ydpi="61.120499" />
651+ xml:space="preserve"
652+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
656+ inkscape:export-xdpi="61.120499"
657+ inkscape:export-ydpi="61.120499"><tspan
658+ sodipodi:role="line"
662+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none">string</tspan></text>
669+ 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"
670+ inkscape:export-xdpi="61.120499"
671+ inkscape:export-ydpi="61.120499" />
676+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
677+ xml:space="preserve"
678+ inkscape:export-xdpi="61.120499"
679+ inkscape:export-ydpi="61.120499"><tspan
680+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
684+ sodipodi:role="line">line</tspan></text>
691+ 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"
692+ inkscape:export-xdpi="61.120499"
693+ inkscape:export-ydpi="61.120499" />
698+ 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.70555556;stroke-miterlimit:4;stroke-dasharray:none"
699+ xml:space="preserve"
700+ inkscape:export-xdpi="61.120499"
701+ inkscape:export-ydpi="61.120499"><tspan
702+ style="font-size:4.23333311px;stroke-width:0.70555556;stroke-miterlimit:4;stroke-dasharray:none"
706+ sodipodi:role="line">col</tspan></text>
708+ 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-end:url(#Arrow1Mend)"
709+ d="m 58.415342,69.700595 -0.143613,-5.887785 4.912582,-0.06048 0.03784,-6.371998"
711+ inkscape:connector-curvature="0"
712+ sodipodi:nodetypes="cccc"
713+ inkscape:export-xdpi="61.120499"
714+ inkscape:export-ydpi="61.120499" />
716+ inkscape:connector-curvature="0"
718+ d="m 89.918872,69.996556 -0.02264,-12.07186"
719+ 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-end:url(#marker1931)"
720+ sodipodi:nodetypes="cc"
721+ inkscape:export-xdpi="61.120499"
722+ inkscape:export-ydpi="61.120499" />
724+ sodipodi:nodetypes="cccc"
725+ 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-end:url(#marker4031)"
726+ d="m 122.08751,69.519138 -0.0832,-5.464386 -2.3456,-0.06048 -0.20406,-6.674425"
728+ inkscape:connector-curvature="0"
729+ inkscape:export-xdpi="61.120499"
730+ inkscape:export-ydpi="61.120499" />
732+ inkscape:connector-curvature="0"
734+ d="m 147.18896,69.882051 -0.0832,-5.827299 -22.72919,0 -0.446,-6.251027"
735+ 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-end:url(#marker7119)"
736+ sodipodi:nodetypes="cccc"
737+ inkscape:export-xdpi="61.120499"
738+ inkscape:export-ydpi="61.120499" />
docs/image/tree.pngnew file
Binary file not shown.
docs/image/tree.svgnew file+212
@@ -0,0 +1,212 @@
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="tree.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 "
39+ bordercolor="#666666"
41+ inkscape:pageopacity="0.0"
42+ inkscape:pageshadow="2"
44+ inkscape:cx="383.03443"
45+ inkscape:cy="690.88799"
46+ inkscape:document-units="px"
47+ inkscape:current-layer="layer1"
49+ inkscape:window-width="1129"
50+ inkscape:window-height="730"
51+ inkscape:window-x="671"
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" />
67+ inkscape:label="Layer 1"
68+ inkscape:groupmode="layer"
72+ style="font-style:normal;font-weight:normal;line-height:0%;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
82+ 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';fill:#0000ff;fill-opacity:1">{hole2} :Nat->Nat</tspan></text>
87+ style="font-style:normal;font-weight:normal;line-height:0%;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"
89+ inkscape:export-xdpi="61.120499"
90+ inkscape:export-ydpi="61.120499"><tspan
91+ 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';fill:#000000;fill-opacity:1"
95+ sodipodi:role="line">intro `{{x}}</tspan></text>
98+ style="font-style:normal;font-weight:normal;line-height:0%;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"
102+ inkscape:export-xdpi="61.120499"
103+ inkscape:export-ydpi="61.120499"><tspan
104+ sodipodi:role="line"
108+ 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';fill:#000000;fill-opacity:1">solve</tspan></text>
113+ style="font-style:normal;font-weight:normal;line-height:0%;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"
114+ xml:space="preserve"
115+ inkscape:export-xdpi="61.120499"
116+ inkscape:export-ydpi="61.120499"><tspan
117+ 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';fill:#000000;fill-opacity:1"
121+ sodipodi:role="line">fill (Var `{{x}})</tspan></text>
123+ style="fill:#0000ff;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(#marker5204)"
124+ d="m 371.4375,343.4872 0.875,29.125"
126+ inkscape:connector-curvature="0"
127+ sodipodi:nodetypes="cc"
128+ inkscape:export-xdpi="61.120499"
129+ inkscape:export-ydpi="61.120499" />
131+ inkscape:export-ydpi="61.120499"
132+ inkscape:export-xdpi="61.120499"
133+ sodipodi:nodetypes="cc"
134+ inkscape:connector-curvature="0"
136+ d="m 371.4375,395.9872 0.875,29.125"
137+ style="fill:#0000ff;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(#marker5204)" />
139+ style="fill:#0000ff;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(#marker5204)"
140+ d="m 371.4375,450.3622 0.875,29.125"
142+ inkscape:connector-curvature="0"
143+ sodipodi:nodetypes="cc"
144+ inkscape:export-xdpi="61.120499"
145+ inkscape:export-ydpi="61.120499" />
147+ inkscape:export-ydpi="61.120499"
148+ inkscape:export-xdpi="61.120499"
152+ style="font-style:normal;font-weight:normal;line-height:0%;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"
153+ xml:space="preserve"><tspan
154+ 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';fill:#ff0000;fill-opacity:1"
158+ sodipodi:role="line">state</tspan></text>
160+ xml:space="preserve"
161+ style="font-style:normal;font-weight:normal;line-height:0%;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+ inkscape:export-xdpi="61.120499"
166+ inkscape:export-ydpi="61.120499"><tspan
167+ sodipodi:role="line"
171+ 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';fill:#ff0000;fill-opacity:1">state</tspan></text>
173+ inkscape:export-ydpi="61.120499"
174+ inkscape:export-xdpi="61.120499"
178+ style="font-style:normal;font-weight:normal;line-height:0%;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"><tspan
180+ 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';fill:#ff0000;fill-opacity:1"
184+ sodipodi:role="line">state</tspan></text>
186+ inkscape:export-ydpi="61.120499"
187+ inkscape:export-xdpi="61.120499"
191+ style="font-style:normal;font-weight:normal;line-height:0%;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"
192+ xml:space="preserve"><tspan
193+ 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';fill:#0000ff;fill-opacity:1"
197+ sodipodi:role="line">λ x:Nat . ? {hole 2}</tspan></text>
199+ xml:space="preserve"
200+ style="font-style:normal;font-weight:normal;line-height:0%;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"
204+ inkscape:export-xdpi="61.120499"
205+ inkscape:export-ydpi="61.120499"><tspan
206+ sodipodi:role="line"
210+ 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';fill:#0000ff;fill-opacity:1">λ x:Nat . x</tspan></text>
@@ -13,105 +13,18 @@ Documentation for the Idris Language
13 Idris Community* has waived all copyright and related or neighboring
13 Idris Community* has waived all copyright and related or neighboring
14 rights to Documentation for Idris.
14 rights to Documentation for Idris.
16− More information concerning the CC0 can be found online at: http://creativecommons.org/publicdomain/zero/1.0/
16+ More information concerning the CC0 can be found online at: https://creativecommons.org/publicdomain/zero/1.0/
19−* :ref:`tutorial-index`
20−* :ref:`eff-tutorial-index`
23−* :ref:`reference-index`
36− tutorial/introduction
53−##########################
54−Frequently Asked Questions
55−##########################
57.. toctree::
19.. toctree::
58 :maxdepth: 1
20 :maxdepth: 1
74− effects/depeff
25+ effects/index
89− proofs/pluscomm
26+ proofs/index
90− proofs/inductive
27+ elaboratorReflection/index
91− proofs/patterns
28+ parserLibrary/index
103− reference/documenting
104− reference/uniqueness-types
29+ reference/index
105− reference/ffi
30+ guides/index
117− guides/type-providers-ffi
docs/listing/idris-prompt-helloworld.txt+2−2
@@ -1,8 +1,8 @@
1$ idris hello.idr
1$ idris hello.idr
3 / _/___/ /____(_)____
3 / _/___/ /____(_)____
4− / // __ / ___/ / ___/ Version 0.9.17
4+ / // __ / ___/ / ___/ Version 1.3.2
5− _/ // /_/ / / / (__ ) http://www.idris-lang.org/
5+ _/ // /_/ / / / (__ ) https://www.idris-lang.org/
6 /___/\__,_/_/ /_/____/ Type :? for help
6 /___/\__,_/_/ /_/____/ Type :? for help
8Type checking ./hello.idr
8Type checking ./hello.idr
docs/listing/idris-prompt-interp.txt+2−2
@@ -1,8 +1,8 @@
1$ idris interp.idr
1$ idris interp.idr
3 / _/___/ /____(_)____
3 / _/___/ /____(_)____
4− / // __ / ___/ / ___/ Version 0.9.17
4+ / // __ / ___/ / ___/ Version 1.3.2
5− _/ // /_/ / / / (__ ) http://www.idris-lang.org/
5+ _/ // /_/ / / / (__ ) https://www.idris-lang.org/
6 /___/\__,_/_/ /_/____/ Type :? for help
6 /___/\__,_/_/ /_/____/ Type :? for help
8Type checking ./interp.idr
8Type checking ./interp.idr
docs/listing/idris-prompt-start.txt+2−2
@@ -1,8 +1,8 @@
3 / _/___/ /____(_)____
3 / _/___/ /____(_)____
4− / // __ / ___/ / ___/ Version 0.9.17
4+ / // __ / ___/ / ___/ Version 1.3.2
5− _/ // /_/ / / / (__ ) http://www.idris-lang.org/
5+ _/ // /_/ / / / (__ ) https://www.idris-lang.org/
6/___/\__,_/_/ /_/____/ Type :? for help
6/___/\__,_/_/ /_/____/ Type :? for help
@@ -65,7 +65,7 @@ if errorlevel 9009 (
65 echo.may add the Sphinx directory to PATH.
65 echo.may add the Sphinx directory to PATH.
67 echo.If you don't have Sphinx installed, grab it from
67 echo.If you don't have Sphinx installed, grab it from
68− echo.http://sphinx-doc.org/
68+ echo.https://www.sphinx-doc.org/
docs/faq/index.rst → docs/parserLibrary/index.rstrenamed+11−6
@@ -1,10 +1,13 @@
1−.. _faq-index:
1+.. _parserLibrary:
3−##########################
3+########################
4−Frequently Asked Questions
4+Lexer and Parser Library
5−##########################
5+########################
7+A tutorial on the lexer and parser library in Idris.
8 The documentation for Idris has been published under the Creative
11 The documentation for Idris has been published under the Creative
9 Commons CC0 License. As such to the extent possible under law, *The
12 Commons CC0 License. As such to the extent possible under law, *The
10 Idris Community* has waived all copyright and related or neighboring
13 Idris Community* has waived all copyright and related or neighboring
@@ -12,8 +15,10 @@ Frequently Asked Questions
13 More information concerning the CC0 can be found online at: http://creativecommons.org/publicdomain/zero/1.0/
16 More information concerning the CC0 can be found online at: http://creativecommons.org/publicdomain/zero/1.0/
16.. toctree::
18.. toctree::
17 :maxdepth: 1
19 :maxdepth: 1
docs/parserLibrary/introduction.rstnew file+76
@@ -0,0 +1,76 @@
1+.. _parserLibraryIntro:
3+***************************
4+Parser Library Introduction
5+***************************
7+The parser library can be used to build Idris structures from text. It involves a
8+certain amount of complexity and so it would typically be used for big projects.
9+An example might be a compiler for another language, written in Idris.
11+Of course the parser library can also be used to compile to Idris, this is what
12+is done in Idris 2 and that is what the this library appears to have been
15+So a secondary use for this tutorial would be to help understanding the internal
18+The parser library is used in a similar way to Parsec which is a library for
19+writing parsers in Haskell. It is based on higher-order parser combinators, so a
20+complicated parser can be made out of many smaller ones.
24+ * - This is a two stage process:
25+ - Lexer - This takes the input string and turns it into a list of Tokens.
26+ - Parser - This takes the list of tokens and outputs the code.
28+ - .. image:: ../image/parserTopLevel.png
31+ :alt: diagram illustrating these stages of lexer and parser
33+The advantage of using two stages, like this, is that things like whitespace and
34+comments don't need to be considered in every parser rule.
36+The Idris parser library differs from Parsec in that you need to say, in the
37+Recogniser, whether a rule is guaranteed to consume input. This means that the
38+Idris type system prevents the construction of recognisers/rules that can't
41+The Lexer is similar but works at the level of characters rather than tokens, and
42+you need to provide a TokenMap which defines how to build a token from
43+a string when a rule is matched.
45+The following pages contain a tutorial for the :ref:`parserLibraryLexer` and a
46+tutorial for the :ref:`parserLibraryParser`. These tutorials have a running
47+example of a parser for integer expressions. This is a very simple example, there
48+may be easier ways to do something so simple, but it illustrates some of the
51+Parser Library and Idris 2
52+--------------------------
54+The parser library, in Idris 1, is almost the same as the code that the Idris 2
55+parser is built on. Even if you only want to use the Idris 1 parser library it
56+is useful to look at the code in the Idris 2 compilers to see how the library
59+Idris 2 has at least 3 compilers:
61+- IDEMode - complies to SExp which is a Lisp-like structure used to communicate
62+ with external editors like Emacs and Vim.
63+- Idris.Parser - This is the main compiler which compiles from a file to
64+ PTerm (and eventually TT structure).
65+- REPL - compiles input from the command line.
67+The following diagram is my first attempt to work out how some of the modules in
68+Idris 2 fit together (with a few of the dependencies between them shown). The
69+Idris 1 library is based on the modules at the bottom of the diagram (shown
72+.. image:: ../image/parserModules.png
75+ :alt: diagram illustrating these stages of lexer and parser
docs/parserLibrary/lexer.rstnew file+288
@@ -0,0 +1,288 @@
1+.. _parserLibraryLexer:
6+The lexer is run by calling the 'lex' function in the Text.Lexer.Core
11+ lex : TokenMap a -> String -> (List (TokenData a), (Int, Int, String))
15+ * - This function takes a String and returns a list of tokens. With the
16+ tokens we have indexes back to the original string which can be used
19+ - .. image:: ../image/tokenise.png
22+ :alt: diagram illustrating these stages of lexer
27+In order to construct this list of tokens we need:
29+- A way to recognise the tokens in the input string.
30+- A way to construct these individual tokens.
32+This is given by the TokenMap which is a list of pairs containing
37+ (Lexer, String -> tokenType)
39+So for each Lexer in the list, if a substring in the input matches, run
40+the associated function to produce a token of type ``tokenType``
44+ * - from Text.Lexer.Core
45+ : https://github.com/idris-lang/Idris-dev/blob/master/libs/contrib/Text/Lexer/Core.idr
47+ - .. code-block:: idris
49+ TokenMap : (tokenType : Type) -> Type
50+ TokenMap tokenType = List (Lexer, String -> tokenType)
52+ * - We can create a tokenMap by using a function like this:
54+ - .. code-block:: idris
56+ myTokenMap : TokenMap Token
57+ myTokenMap = [(is 'a',CharLit)]
59+Once we have a TokenMap we can use it to lex many strings.
64+The first part of each entry in the TokenMap is the recogniser.
66+A simple recogniser is 'Pred' which uses a predicate (Char -> Bool) to
67+test whether to accept the character. It can be constructed using the
74+ intToBool (prim__eqChar ARG 'a'))
77+More complicated structures can be recognised as tokens, this is done using
78+the combinator structure of recognisers. This allows recognisers to be
79+combined, for example,
83+ * - ``<+>`` means sequence two recognisers. If either consumes a character,
84+ the sequence is guaranteed to consume a character.
86+ - .. code-block:: idris
88+ *parserEx> is 'a' <+> is 'b'
89+ SeqEat (Pred (\ARG => intToBool (prim__eqChar ARG 'a')))
90+ (Delay (is 'b')) : Recognise True
92+ * - ``<|>`` means if both consume, the combination is guaranteed
93+ to consumer a character:
95+ - .. code-block:: idris
97+ *parserEx> is 'a' <|> is 'b'
98+ Alt (Pred (\ARG => intToBool (prim__eqChar ARG 'a')))
99+ (Pred (\ARG => intToBool (prim__eqChar ARG 'b')))
102+This diagram shows the recogniser combinator with some of its constructors:
104+.. image:: ../image/recogniser.png
107+ :alt: recogniser data structure
109+A recogniser consumes its input, that is it advances the index to its input
110+string, as it generates the token list. In some cases we don't want this to
111+happen, for instance, we may need to lookahead before consuming the input
114+If a recogniser does not consume input there is a danger of an infinite loop.
115+To prevent this the recogniser is dependent on a boolean called 'consumes' which
116+is true if the recogniser is guaranteed to consume at least one character.
118+The constructors of Recognise allow us to ensure that, even though parts of
119+the recogniser may not consume, overall the recogniser will consume.
121+Since 'Recognise True' is more common than 'Recognise False' it is convenient to
122+use 'Lexer' as a type synonym for 'Recognise True'.
124+Whitespace and Comments
125+-----------------------
127+An important reason to have a lexer is to simplify the parser when whitespace
128+or comments are required. Without this the parser would require a match for
129+every combination, with and without, whitespace and comments.
131+In some languages the lexer needs to remove whitespace and comments so that
132+they don't appear in the token list. In some cases whitespace is significant
133+but a single whitespace token can stand for any number of spaces, tabs,
134+carriage returns and so on.
136+In some cases, such as when parsing the Idris language itself, whitespace
137+is important to indicate blocks. In this case we might want to output a
138+start-of-block token when the indent increases and an end-of-block token
139+when the indent decreases.
141+This topic will be discussed more fully on this page
142+:ref:`parserLibraryWhitespace`.
144+Simple Expression Example for Lexer
145+-----------------------------------
147+On this page we will implement a lexer to 'lex' a very simple expression as
148+a running example, on the next page, we will go on to implement a parser for it.
150+First import the lexer and parser code:
152+.. code-block:: idris
154+ module ParserExample
157+ import public Text.Parser.Core
158+ import public Text.Parser
160+Then decide on the tokens that are needed. For this example the idea is to be
161+able to parse simple arithmetic expressions, like this:
163+.. code-block:: idris
169+- Numbers (for now integer literals are good enough).
170+- Some operators (for now ``+``, ``-`` and ``*`` will do.
171+- Opening and closing Parentheses.
173+We can define these, as tokens, like this:
175+.. code-block:: idris
180+ data ExpressionToken = Number Integer
186+It may help with debugging and to implement error messages to
187+implement ``show`` for these tokens:
189+.. code-block:: idris
192+ Show ExpressionToken where
193+ show (Number x) = "number " ++ show x
194+ show (Operator x) = "operator " ++ x
197+ show EndInput = "end of input"
200+ Show (TokenData ExpressionToken) where
201+ show (MkToken l c t) = "line=" ++ show l ++ " col=" ++ show c ++ "tok=" ++ show t
203+The following defines the 'TokenMap' for this example:
205+.. code-block:: idris
207+ ||| integer arithmetic operators plus, minus and multiply.
213+ operator = some (oneOf opChars)
215+ toInt' : String -> Integer
218+ expressionTokens : TokenMap ExpressionToken
220+ [(digits, \x => Number (toInt' x)),
221+ (operator, \x => Operator x),
222+ (is '(' ,\x => OParen),
223+ (is ')' ,\x => CParen)]
225+This specifies the lexer. It gives, for each token, a function to recognise
226+the token type and a function to construct the token.
228+The library module 'Text.Lexer' contains useful functions to help with this.
229+For example, the digits function used above, which reads one or more
232+We can now run the code with various strings to see what output the lexer
233+produces. This is done by calling the 'lex' function with the TokenMap and
234+input string as parameters:
236+.. code-block:: idris
238+ cd Idris-dev/libs/contrib
239+ idris -p contrib parserEx.idr
241+ / _/___/ /____(_)____
242+ / // __ / ___/ / ___/ Version 1.3.2
243+ _/ // /_/ / / / (__ ) http://www.idris-lang.org/
244+ /___/\__,_/_/ /_/____/ Type :? for help
246+ Idris is free software with ABSOLUTELY NO WARRANTY.
247+ For details type :warranty.
248+ Type checking ./Text/Token.idr
249+ Type checking ./Text/Quantity.idr
250+ Type checking ./Control/Delayed.idr
251+ Type checking ./Data/Bool/Extra.idr
252+ Type checking ./Text/Lexer/Core.idr
253+ Type checking ./Text/Lexer.idr
254+ Type checking ./parserEx.idr
256+ *parserEx> lex expressionTokens "1+2"
257+ ([MkToken 0 0 (Number 1),
259+ (case fspan (\ARG => not (intToBool (prim__eqChar ARG '\n'))) "1" of
260+ (incol, "") => c + cast (length incol)
261+ (incol, b) => cast (length incol))
264+ (case fspan (\ARG => not (intToBool (prim__eqChar ARG '\n'))) "+" of
265+ (incol, "") => c + cast (length incol)
266+ (incol, b) => cast (length incol))
269+ case fspan (\ARG => not (intToBool (prim__eqChar ARG '\n'))) "2" of
270+ (incol, "") => c + cast (length incol)
271+ (incol, b) => cast (length incol),
272+ getString (MkStrLen "" 0)) : (List (TokenData ExpressionToken),
277+The lexer uses potentially infinite data structures. It has recursive
278+arguments (codata type) so code is lazy. In the output above the indexes
279+have not been computed but we can pick out the tokens:
285+So the code is working.
287+We can now go ahead and parse this token list. A parser for this example will
288+be constructed on the next page.
docs/parserLibrary/parser.rstnew file+700
@@ -0,0 +1,700 @@
1+.. _parserLibraryParser:
6+To run the parser we call ``parse``. This requires a grammar and the output
7+from the lexer (which is a list of tokens).
11+ parse : (act : Grammar tok c ty) -> (xs : List tok) ->
12+ Either (ParseError tok) (ty, List tok)
14+If successful this returns 'Right' with a pair of
17+- the unparsed tokens (the remaining input).
19+otherwise it returns 'Left' with the error message.
21+So we need to define the grammar for our parser, this is done using the following
22+'Grammar' data structure. This is a combinator structure, similar in principle
23+to the recogniser combinator for the lexer, which was discussed on the
26+As with the Recogniser the ``Grammar`` type is dependent on a boolean 'consumes'
27+value which allows us to ensure that complicated ``Grammar`` structures will always
32+ ||| Description of a language's grammar. The `tok` parameter is the type
33+ ||| of tokens, and the `consumes` flag is True if the language is guaranteed
34+ ||| to be non-empty - that is, successfully parsing the language is guaranteed
35+ ||| to consume some input.
37+ data Grammar : (tok : Type) -> (consumes : Bool) -> Type -> Type where
38+ Empty : (val : ty) -> Grammar tok False ty
39+ Terminal : String -> (tok -> Maybe a) -> Grammar tok True a
40+ NextIs : String -> (tok -> Bool) -> Grammar tok False tok
41+ EOF : Grammar tok False ()
43+ Fail : Bool -> String -> Grammar tok c ty
44+ Commit : Grammar tok False ()
45+ MustWork : Grammar tok c a -> Grammar tok c a
47+ SeqEat : Grammar tok True a -> Inf (a -> Grammar tok c2 b) ->
49+ SeqEmpty : {c1, c2 : Bool} ->
50+ Grammar tok c1 a -> (a -> Grammar tok c2 b) ->
51+ Grammar tok (c1 || c2) b
52+ Alt : {c1, c2 : Bool} ->
53+ Grammar tok c1 ty -> Grammar tok c2 ty ->
54+ Grammar tok (c1 && c2) ty
56+So an example of a grammer type may look something like this:
57+``Grammar (TokenData ExpressionToken) True Integer``.
58+This is a complicated type name and a given parser will need to use it a lot.
59+So to reduce the amount of typing we can use the following type synonym (similar
60+to what is done in Idris 2
61+: https://github.com/edwinb/Idris2/blob/master/src/Parser/Support.idr
68+ Rule ty = Grammar (TokenData ExpressionToken) True ty
73+On the previous page we implemented a lexer to 'lex' a very simple expression, on
74+this page we will go on to add a parser for this running example.
78+ * - The syntax we are aiming at is something
79+ like this (expressed in Backus–Naur form (BNF)):
80+ - .. code-block:: idris
82+ <expr> ::= <integer literal>
88+ <integer literal> ::= <digit>|<integer literal><digit>
92+ * - To start, here is a grammar to parse an integer literal (that is, a
93+ sequence of numeric characters).
95+ - .. code-block:: idris
98+ intLiteral : Rule Integer
100+ = terminal (\x => case tok x of
104+In order to try this out, here is a temporary function, this calls
105+parse which takes two parameters:
107+- The grammar (in this case intLiteral)
108+- The token list from the lexer.
110+.. code-block:: idris
112+ test1 : String -> Either (ParseError (TokenData ExpressionToken))
113+ (Integer, List (TokenData ExpressionToken))
114+ test1 s = parse intLiteral (fst (lex expressionTokens s))
116+As required, if we pass it a string which is a number literal then it will
117+return the number in the 'Right' option.
119+.. code-block:: idris
121+ *parserEx> test1 "123"
122+ Right (123, []) : Either (ParseError (TokenData ExpressionToken))
123+ (Integer, List (TokenData ExpressionToken))
125+If we pass it a string which is not a number literal then it will return an
128+.. code-block:: idris
130+ *parserEx> test1 "a"
131+ Left (Error "End of input"
132+ []) : Either (ParseError (TokenData ExpressionToken))
133+ (Integer, List (TokenData ExpressionToken))
135+If we pass it a number followed by something else, then it will still be
136+successful, this is because we are not specifically checking for end-of-file.
138+.. code-block:: idris
140+ *parserEx> test1 "123a"
141+ Right (123, []) : Either (ParseError (TokenData ExpressionToken))
142+ (Integer, List (TokenData ExpressionToken))
147+ * - The ``intLiteral`` function above uses the ``terminal`` function to
148+ construct the grammar
149+ - .. code-block:: idris
151+ ||| Succeeds if running the predicate on the
152+ ||| next token returns Just x, returning x.
153+ ||| Otherwise fails.
155+ terminal : (tok -> Maybe a) -> Grammar tok True a
159+: https://github.com/idris-lang/Idris-dev/blob/master/libs/contrib/Text/Parser/Core.idr
160+Idris 2 uses a slightly different version which stores an error message like
161+"Expected integer literal" which can be output if the rule fails
162+: https://github.com/edwinb/Idris2/blob/master/src/Text/Parser/Core.idr
166+ * - The 'terminal' function is also used to construct the other
167+ elements of the grammar that we require, for instance,
168+ opening parenthesis:
170+ - .. code-block:: idris
172+ openParen : Rule Integer
173+ openParen = terminal (\x => case tok x of
177+Integer value is not really relevant for parenthesis so ``0`` (zero) is used as
180+As before, this can be tested with a function like this:
182+.. code-block:: idris
184+ test2 : String -> Either (ParseError (TokenData ExpressionToken))
185+ (Integer, List (TokenData ExpressionToken))
186+ test2 s = parse openParen (fst (lex expressionTokens s))
188+We can see below that it correctly parses an open parenthesis and gives an
189+error for anything else:
191+.. code-block:: idris
193+ *parserEx> test2 "("
194+ Right (0, []) : Either (ParseError (TokenData ExpressionToken))
195+ (Integer, List (TokenData ExpressionToken))
196+ *parserEx> test2 "123"
197+ Left (Error "Unrecognised token"
200+ (Number 123)]) : Either (ParseError (TokenData ExpressionToken))
202+ List (TokenData ExpressionToken))
204+Now we have two Grammars we can try combining them. The following test looks
205+for ``openParen`` followed by ``intLiteral``, the two Grammars are combined using
206+``<*>``. The ``map const`` part uses the integer value from the first.
208+The following test is looking for ``(`` followed by a number:
210+.. code-block:: idris
212+ test3 : String -> Either (ParseError (TokenData ExpressionToken))
213+ (Integer, List (TokenData ExpressionToken))
214+ test3 s = parse (map const openParen <*> intLiteral) (fst (lex expressionTokens s))
216+We can see below that ``(`` followed by a number is successfully parsed but, as
217+required, other token lists are not:
219+.. code-block:: idris
221+ *parserEx> test3 "(123"
222+ Right (0, []) : Either (ParseError (TokenData ExpressionToken))
223+ (Integer, List (TokenData ExpressionToken))
224+ *parserEx> test3 "(("
225+ Left (Error "Unrecognised token"
227+ (case fspan (\ARG => not (intToBool (prim__eqChar ARG '\n')))
229+ (incol, "") => c + cast (length incol)
230+ (incol, b) => cast (length incol))
231+ OParen]) : Either (ParseError (TokenData ExpressionToken))
232+ (Integer, List (TokenData ExpressionToken))
234+ *parserEx> test3 "123"
235+ Left (Error "Unrecognised token"
238+ (Number 123)]) : Either (ParseError (TokenData ExpressionToken))
240+ List (TokenData ExpressionToken))
241+ *parserEx> test3 "123("
242+ Left (Error "Unrecognised token"
243+ [MkToken 0 0 (Number 123),
245+ (case fspan (\ARG => not (intToBool (prim__eqChar ARG '\n')))
247+ (incol, "") => c + cast (length incol)
248+ (incol, b) => cast (length incol))
249+ OParen]) : Either (ParseError (TokenData ExpressionToken))
250+ (Integer, List (TokenData ExpressionToken))
254+ * - The closing parenthesis is constructed in the same way.
256+ - .. code-block:: idris
258+ closeParen : Rule Integer
259+ closeParen = terminal (\x => case tok x of
265+ * - Now we can generate a Grammar for an expression inside parenthesis
268+ - .. code-block:: idris
270+ paren : Rule Integer -> Rule Integer
271+ paren exp = openParen *> exp <* closeParen
273+The use of ``*>`` and ``<*`` instead of ``<*>`` is an easy way to use the integer
274+value from the inner expression.
276+So lets try to use this to define a grammar which recognises either:
279+- An integer literal inside parenthesis
280+- An integer literal inside parenthesis inside parenthesis
285+ * - This requires a recursively defined structure like this:
287+ - .. code-block:: idris
291+ expr = intLiteral <|> (paren expr)
293+This is a valid grammar because every time it is called it is guaranteed to
294+consume a token. However, as an Idris structure, it is problematic due to
295+the recursion. Defining it as partial allows it to compile but at runtime
296+we are likely to get a crash with an (unhelpful) error message like
297+``killed by signal 11``.
299+So a better method is to use ``do`` notation as described in the following
305+In addition to ``<|>`` and ``<*>`` there is a ``>>=`` combinator, which is
308+.. code-block:: idris
310+ ||| Sequence two grammars. If either consumes some input, the sequence is
311+ ||| guaranteed to consume some input. If the first one consumes input, the
312+ ||| second is allowed to be recursive (because it means some input has been
313+ ||| consumed and therefore the input is smaller)
315+ (>>=) : {c1 : Bool} ->
317+ inf c1 (a -> Grammar tok c2 b) ->
318+ Grammar tok (c1 || c2) b
319+ (>>=) {c1 = False} = SeqEmpty
320+ (>>=) {c1 = True} = SeqEat
324+ * - This allows us to use ``do`` notation for the previous parenthesis example:
326+ - .. code-block:: idris
328+ expr = intLiteral <|> do
334+This can be more flexible than using the ``<*>`` operator. Also it is defined
335+using ``Inf`` so we can implement recursively defined grammars as above.
337+Implementing the Arithmetic Operators
338+-------------------------------------
342+ * - Now for the operations, in this case: ``+``, ``-`` and ``*``.
343+ The syntax we require for these infix operators
344+ would require recursive grammars like this:
346+ - .. code-block:: idris
348+ expr = expr (op "+") expr
350+As already explained, ``do`` notation can allow us to use recursive
351+definitions but not necessarily left-recursion like this.
353+In order to work up to this gradually lets start with prefix operators
354+(sometimes known as Polish notation) then modify later for infix operators.
358+ * - So prefix operators would have this sort of form:
360+ - .. code-block:: idris
362+ expr = (add (op "+") expr expr)
364+where ``op`` is defined like this:
366+.. code-block:: idris
368+ ||| Matches if this is an operator token and string matches, that is,
369+ ||| it is the required type of operator.
370+ op : String -> Rule Integer
371+ op s = terminal (\x => case tok x of
372+ (Operator s1) => if s==s1 then Just 0 else Nothing
377+ * - and ``add`` is defined like this:
381+ - x is the add operator.
382+ - y is the first operand.
383+ - z is the second operand.
385+ - .. code-block:: idris
387+ addInt : Integer -> Integer -> Integer
391+ add : Grammar tok c1 Integer ->
392+ Grammar tok c2 Integer ->
393+ Grammar tok c3 Integer ->
394+ Grammar tok ((c1 || c2) || c3) Integer
395+ add x y z = map addInt (x *> y) <*> z
399+The resulting integer will be the sum of the two operands.
403+ * - The other operators are defined in a similar way:
405+ - .. code-block:: idris
407+ subInt : Integer -> Integer -> Integer
411+ sub : Grammar tok c1 Integer ->
412+ Grammar tok c2 Integer ->
413+ Grammar tok c3 Integer ->
414+ Grammar tok ((c1 || c2) || c3) Integer
415+ sub x y z = map subInt (x *> y) <*> z
417+ multInt : Integer -> Integer -> Integer
421+ mult : Grammar tok c1 Integer ->
422+ Grammar tok c2 Integer ->
423+ Grammar tok c3 Integer ->
424+ Grammar tok ((c1 || c2) || c3) Integer
425+ mult x y z = map multInt (x *> y) <*> z
427+So the top level ``Grammar`` can now be defined as follows. Note that this is
428+partial as it is a potentially infinite structure and so not total.
430+.. code-block:: idris
434+ expr = (add (op "+") expr expr)
435+ <|> (sub (op "-") expr expr)
436+ <|> (mult (op "*") expr expr)
437+ <|> intLiteral <|> (paren expr)
441+ * - To make the testing easier we can use this function:
443+ - .. code-block:: idris
446+ test : String -> Either (ParseError (TokenData ExpressionToken))
447+ (Integer, List (TokenData ExpressionToken))
448+ test s = parse expr (fst (lex expressionTokens s))
452+ * - First test a valid (prefix) expression:
454+ - .. code-block:: idris
456+ *parserEx> test "+1*6(4)"
458+ []) : Either (ParseError (TokenData ExpressionToken))
459+ (Integer, List (TokenData ExpressionToken))
461+Then an invalid syntax:
463+.. code-block:: idris
465+ *parserEx> test "))"
466+ Left (Error "Unrecognised token"
467+ [MkToken 0 0 CParen,
469+ (case fspan (\ARG =>
470+ not (intToBool (prim__eqChar ARG
473+ (incol, "") => c + cast (length incol)
474+ (incol, b) => cast (length incol))
475+ CParen]) : Either (ParseError (TokenData ExpressionToken))
477+ List (TokenData ExpressionToken))
479+However if we try something that is invalid, but starts with a valid token,
480+then it will return ``Right`` (to indicate success)
482+.. code-block:: idris
484+ *parserEx> test "1))"
487+ (case fspan (\ARG =>
488+ not (intToBool (prim__eqChar ARG '\n')))
490+ (incol, "") => c + cast (length incol)
491+ (incol, b) => cast (length incol))
494+ (case fspan (\ARG =>
495+ not (intToBool (prim__eqChar ARG '\n')))
497+ (incol, "") => c + cast (length incol)
498+ (incol, b) => cast (length incol))
499+ CParen]) : Either (ParseError (TokenData ExpressionToken))
501+ List (TokenData ExpressionToken))
506+So far we have implemented a prefix notation for operators (like this:
507+``+ expr expr``) but the aim is to implemented an infix notation (like this:
508+``expr + expr``). To do this we must be able to deal with potentially
509+infinite data structures (see Codata Types here :ref:`sect-typefuns`).
511+First alter the grammar to have infix operations:
513+.. code-block:: idris
515+ addInt : Integer -> Integer -> Integer
519+ add : Grammar tok c1 Integer ->
520+ Grammar tok c2 Integer ->
521+ Grammar tok c3 Integer ->
522+ Grammar tok ((c1 || c2) || c3) Integer
523+ add x y z = map addInt (x <* y) <*> z
525+ subInt : Integer -> Integer -> Integer
529+ sub : Grammar tok c1 Integer ->
530+ Grammar tok c2 Integer ->
531+ Grammar tok c3 Integer ->
532+ Grammar tok ((c1 || c2) || c3) Integer
533+ sub x y z = map subInt (x <* y) <*> z
536+ multInt : Integer -> Integer -> Integer
540+ mult : Grammar tok c1 Integer ->
541+ Grammar tok c2 Integer ->
542+ Grammar tok c3 Integer ->
543+ Grammar tok ((c1 || c2) || c3) Integer
544+ mult x y z = map multInt (x <* y) <*> z
548+ expr = (add expr (op "+") expr)
549+ <|> (sub expr (op "-") expr)
550+ <|> (mult expr (op "*") expr)
551+ <|> intLiteral <|> (paren expr)
553+However, if this was run, the code would not terminate.
555+Implement Left Recursion Elimination
556+------------------------------------
558+Left factoring, like this, is a general problem.
560+If we have a rule like this:
562+.. code-block:: idris
564+ A -> (x<*>y) <|> (x<*>z)
566+If ``x<*>y`` fails but ``x<*>z`` would succeed a problem is that, ``x<*>y`` has
567+already consumed ``x``, so now ``x<*>z`` will fail.
569+so we could write code to backtrack. That is ``try`` ``x<*>y`` without consuming
570+so that, if the first token succeeds but the following tokens fail, then the
571+first tokens would not be consumed.
573+Another approach is left factoring:
578+Replace the rule with two rules (that is we add a non-terminal symbol) so
579+for example, instead of:
581+.. code-block:: idris
583+ A -> (x<*>y) <|> (x<*>z)
585+we add an extra rule to give:
587+.. code-block:: idris
592+That is we convert a general context-free grammar to a LL(1) grammar. Although
593+not every context-free grammar can be converted to a LL(1) grammar.
595+This still does not solve the infinite recursion issue and there is another
596+problem: the precedence of the operators ``+``, ``-`` and ``*`` is not explicit.
600+ * - To resolve this we can alter the example to have a BNF like this:
601+ Where braces ``{ ... }`` mean the contents can occur 1 or more times.
603+ - .. code-block:: idris
605+ 'expression' ::= ('+'|'-') 'term' {('+'|'-') 'term'}
607+ 'term' ::= 'factor' {'*' 'factor'}
611+ | '(' 'expression' ')'
614+.. code-block:: idris
618+ factor : Rule Integer
619+ factor = intLiteral <|> do
626+ term = map multInt factor <*> (
631+ expr = map addInt term <*> (
634+ <|> map subInt term <*> (
639+ calc : String -> Either (ParseError (TokenData ExpressionToken))
640+ (Integer, List (TokenData ExpressionToken))
641+ calc s = parse expr (fst (lex expressionTokens s))
643+ lft : (ParseError (TokenData ExpressionToken)) -> IO ()
644+ lft (Error s lst) = putStrLn ("error:"++s)
646+ rht : (Integer, List (TokenData ExpressionToken)) -> IO ()
647+ rht i = putStrLn ("right " ++ (show i))
653+ either lft rht (calc x) -- eliminator for Either
655+As the following tests show, this now handles infix operators and precedence.
659+ * - For example '*' is an infix operator:
661+ - .. code-block:: idris
667+ * - Check that atomic number literals work:
669+ - .. code-block:: idris
675+ * - Check that '*' has a higher precedence than '+'.
677+ - .. code-block:: idris
683+ * - Also '*' has a higher precedence than '+' when the order is reversed.
685+ - .. code-block:: idris
691+ * - Also precedence can be overridden by parenthesis.
693+ - .. code-block:: idris
699+This is still not correct because it does not correctly parse multiple sums or terms
700+like ``1+2+3`` or ``1*2*3``.
docs/parserLibrary/whitespace.rstnew file+250
@@ -0,0 +1,250 @@
1+.. _parserLibraryWhitespace:
3+Whitespace and Comments
4+=======================
6+The previous two pages introduced the lexer and parser but have not yet
7+discussed how to handle whitespace and comments.
9+In some grammars whitespace and comments would not be considered significant and
10+so we might be tempted not to generate any tokens for them. However, in the
11+running example, we may want to make spaces significant in the future. For
12+example, we might want to implement function application expressed by
13+juxtaposition as in Haskell and Idris like this: ``f x``.
15+So, on this page, we will add a token for whitespace and comments. We will
16+then consider two ways to process this:
18+- Filter all whitespace tokens from the lexer results before passing to
20+- Process the whitespace tokens in the parser.
22+Whitespace and Comments in Lexer
23+--------------------------------
25+To start with we can use the same token for both whitespace and comments. Here
26+it is called ``Comment`` and added to the ``ExpressionToken`` data structure
32+ data ExpressionToken = Number Integer
39+This is added to the ``TokenMap`` like this:
43+ ||| from https://github.com/edwinb/Idris2/blob/master/src/Parser/Lexer.idr
45+ comment = is '-' <+> is '-' <+> many (isNot '\n')
47+ expressionTokens : TokenMap ExpressionToken
49+ [(digits, \x => Number (toInt' x)),
50+ (operator, \x => Operator x),
51+ (is '(' ,\x => OParen),
52+ (is ')' ,\x => CParen),
56+As you can see, the comment is defined like a single line Idris comment,
57+it starts with ``--`` and continues for the remainder of the line.
59+We don't need to define ``spaces`` because it is already defined in
60+: https://github.com/idris-lang/Idris-dev/blob/master/libs/contrib/Text/Lexer.idr
65+ ||| Recognise a single whitespace character
70+ ||| Recognise one or more whitespace characters
75+If these whitespace tokens are not significant, that is, they can appear
76+anywhere and they are optional then we can filter them out before the parser
81+ processWhitespace : (List (TokenData ExpressionToken), Int, Int, String)
82+ -> (List (TokenData ExpressionToken), Int, Int, String)
83+ processWhitespace (x,l,c,s) = ((filter notComment x),l,c,s) where
84+ notComment : TokenData ExpressionToken -> Bool
85+ notComment t = case tok t of
89+ calc : String -> Either (ParseError (TokenData ExpressionToken))
90+ (Integer, List (TokenData ExpressionToken))
91+ calc s = parse expr (fst (processWhitespace (lex expressionTokens s)))
94+Whitespace and Comments in Parser
95+---------------------------------
97+If we sometimes require whitespace to be significant then we can't filter
98+them out as above. In this case the ``Comment`` tokens are sent to the parser
99+which now needs to be able to handle them.
101+.. code-block:: idris
103+ commentSpace : Rule Integer
104+ commentSpace = terminal (\x => case tok x of
108+So far we don't have any syntax that requires spaces to be significant so we
109+need to define the grammar so that it will parse with, or without, spaces.
110+This needs to be done in a systematic way, here I have defined the grammar so
111+that there is an optional space to the right of every atom or operator.
112+First add versions of ``intLiteral`` , ``openParen`` , ``closeParen``
113+and ``op`` that allow optional spaces/comments to the right of them:
115+.. code-block:: idris
117+ intLiteralC : Rule Integer
118+ intLiteralC = (intLiteral <* commentSpace) <|> intLiteral
120+ openParenC : Rule Integer
121+ openParenC = (openParen <* commentSpace) <|> openParen
123+ closeParenC : Rule Integer
124+ closeParenC = (closeParen <* commentSpace) <|> closeParen
126+ ||| like op but followed by optional comment or space
127+ opC : String -> Rule Integer
128+ opC s = ((op s) <* commentSpace) <|> (op s)
130+Then just use these functions instead of the original functions:
132+.. code-block:: idris
136+ factor : Rule Integer
137+ factor = intLiteralC <|> do
144+ term = map multInt factor <*> (
149+ expr = map addInt term <*> (
152+ <|> map subInt term <*> (
157+ calc : String -> Either (ParseError (TokenData ExpressionToken))
158+ (Integer, List (TokenData ExpressionToken))
159+ calc s = parse expr (fst (lex expressionTokens s))
161+ lft : (ParseError (TokenData ExpressionToken)) -> IO ()
162+ lft (Error s lst) = putStrLn ("error:"++s)
164+ rht : (Integer, List (TokenData ExpressionToken)) -> IO ()
165+ rht i = putStrLn ("right " ++ (show i))
171+ either lft rht (calc x) -- eliminator for Either
174+Defining Block Structure using Indents
175+--------------------------------------
177+Many languages such as Python, Haskell and Idris use indents to delimit
178+the block structure of the language.
180+We can see how Idris2 does it here
181+: https://github.com/edwinb/Idris2/blob/master/src/Parser/Support.idr
183+.. code-block:: idris
196+So far, the parser will return a successful result even if the full input
197+is not consumed. To ensure that the top level syntax is fully matched we
198+add a ``EndInput`` token to indicate the last token.
200+``EndInput`` is added to the other tokens like this:
202+.. code-block:: idris
204+ data ExpressionToken = Number Integer
211+A rule to consume this token is added:
213+.. code-block:: idris
216+ eoi = terminal (\x => case tok x of
220+Instead of using ``expr`` at the top level of the syntax we can now define
221+``exprFull`` as shown here. This will make sure that only when ``EndInput``
222+is consumed will the parse be successful:
224+.. code-block:: idris
226+ exprFull : Rule Integer
227+ exprFull = expr <* eoi
229+The following code makes sure ``EndInput`` is added to the end of the token
232+.. code-block:: idris
234+ processWhitespace : (List (TokenData ExpressionToken), Int, Int, String)
235+ -> (List (TokenData ExpressionToken), Int, Int, String)
236+ processWhitespace (x,l,c,s) = ((filter notComment x)++
237+ [MkToken l c EndInput],l,c,s) where
238+ notComment : TokenData ExpressionToken -> Bool
239+ notComment t = case tok t of
243+All we have to do now is use ``exprFull`` instead of ``expr``:
245+.. code-block:: idris
247+ calc : String -> Either (ParseError (TokenData ExpressionToken))
248+ (Integer, List (TokenData ExpressionToken))
249+ calc s = parse exprFull (fst (processWhitespace (lex expressionTokens s)))
docs/proofs/definitional.rstnew file+235
@@ -0,0 +1,235 @@
5+In order to understand how to write proofs in Idris I think its worth clarifying some fundamentals, such as,
7+- Propositions and judgments
8+- Boolean and constructive logic
9+- Curry-Howard correspondence
10+- Definitional and propositional equalities
11+- Axiomatic and constructive approaches
13+Propositions and Judgments
14+==========================
16+Propositions are the subject of our proofs, before the proof then we can't formally say if they are true or not. If the proof is successful then the result is a 'judgment'.
17+For instance, if the ``proposition`` is,
23+When we prove it, the ``judgment`` is,
29+Or if the ``proposition`` is,
35+Obviously we can't prove it is true, but it is still a valid proposition and perhaps we can prove it is false so the ``judgment`` is,
41+This may seem a bit pedantic but it is important to be careful, in mathematics not every proposition is true or false for instance, a proposition may be unproven or even unprovable.
43+So the logic here is different from the logic that comes from boolean algebra. In that case what is not true is false and what is not false is true. The logic we are using here does not have this 'law of excluded middle' so we have to be careful not to use it.
45+A false proposition is taken to be a contradiction and if we have a contradiction then we can prove anything, so we need to avoid this. Some languages, used in proof assistants, prevent contradictions but such languages cannot be Turing complete, so Idris does not prevent contradictions.
47+The logic we are using is called constructive (or sometimes intuitional) because we are constructing a 'database' of judgments.
49+There are also many other types of logic, another important type of logic for Idris programmers is '``linear logic``' but that's not discussed on this page.
51+Curry-Howard correspondence
52+===========================
54+So how to we relate these proofs to Idris programs? It turns out that there is a correspondence between constructive logic and type theory. They are the same structure and we can switch backward and forward between the two notations because they are the same thing.
56+The way that this works is that a proposition is a type so this,
63+is a proposition and it is also a type. This is built into Idris so when an '=' equals sign appears in a function type an equality type is generated. The following will also produce an equality type:
71+Both of these are valid propositions so both are valid equality types. But how do we represent true judgment, that is, how do we denote 1+1=2 is true but not 1+1=3.
72+A type that is true is inhabited, that is, it can be constructed. An equality type has only one constructor 'Refl' so a proof of 1+1=2 is
79+So how can Refl, which is a constructor without any parameters, construct an equality type? If we type it on its own then it can't:
84+ (input):Can't infer argument A to Refl, Can't infer argument x to Refl
86+So it must pattern match on its return type:
90+ Idris> the (1=1) Refl
93+So now that we can represent propositions as types other aspects of propositional logic can also be translated to types as follows:
95++----------+-------------------+--------------------------+
96+| | propositions | example of possible type |
97++----------+-------------------+--------------------------+
99++----------+-------------------+--------------------------+
101++----------+-------------------+--------------------------+
102+| and | A /\\ B | ``Pair(x=y,y=z)`` |
103++----------+-------------------+--------------------------+
104+| or | A \\/ B | ``Either(x=y,y=z)`` |
105++----------+-------------------+--------------------------+
106+| implies | A -> B | ``(x=y) -> (y=x)`` |
107++----------+-------------------+--------------------------+
109++----------+-------------------+--------------------------+
111++----------+-------------------+--------------------------+
117+We can have a type which corresponds to conjunction:
119+.. code-block:: idris
121+ AndIntro : a -> b -> A a b
123+There is a built in type called 'Pair'.
128+We can have a type which corresponds to disjunction:
130+.. code-block:: idris
132+ data Or : Type -> Type -> Type where
133+ OrIntroLeft : a -> A a b
134+ OrIntroRight : b -> A a b
136+There is a built in type called 'Either'.
138+Definitional and Propositional Equalities
139+=========================================
141+We have seen that we can 'prove' a type by finding a way to construct a term. In the case of equality types there is only one constructor which is 'Refl'.
142+We have also seen that each side of the equation does not have to be identical like '2=2'. It is enough that both sides are ``definitionaly equal`` like this:
144+.. code-block:: idris
149+So both sides of this equation nomalise to 2 and so Refl will type match and the proposition is proved.
151+We don't have to stick to terms, can also use symbolic parameters so the following will compile:
153+.. code-block:: idris
158+If a proposition/equality type is not definitionaly equal but is still true then it is ``propositionaly equal``. In this case we may still be able to prove it but some steps in the proof may require us to add something into the terms or at least to take some sideways steps to get to a proof.
160+Especially when working with equalities containing variable terms (inside functions) it can be hard to know which equality types are definitially equal, in this example plusReducesL is '``definitially equal``' but plusReducesR is not (although it is '``propositionaly equal``'). The only difference between them is the order of the operands.
162+.. code-block:: idris
164+ plusReducesL : (n:Nat) -> plus Z n = n
165+ plusReducesL n = Refl
167+ plusReducesR : (n:Nat) -> plus n Z = n
168+ plusReducesR n = Refl
170+plusReducesR gives the following error:
173+.. code-block:: idris
176+ `-- proof.idr line 6 col 17:
177+ When checking right hand side of plusReducesR with expected type
180+ Type mismatch between
181+ n = n (Type of Refl)
183+ plus n 0 = n (Expected type)
186+ Type mismatch between
191+So why is 'Refl' able to prove some equality types but not others?
193+The first answer is that 'plus' is defined in such a way that it splits on its first argument so it is simple to prove when 0 is the first argument but not the second. So what is the general way to know if Refl will work?
195+If an equality type can be proved/constructed by using Refl alone it is known as a ``definitional equality``. In order to be definitinally equal both sides of the equation must normalise to unique values. That is, each step in the proof must reduce the term so each step is effectively forced.
197+So when we type 1+1 in Idris it is immediately converted to 2 because definitional equality is built in.
199+.. code-block:: idris
204+In the following pages we discuss how to resolve propositionaly equalies.
206+Axiomatic and Constructive Approaches
207+=====================================
209+How should we define types so that we can do proofs on them? In the natural numbers with the plus example we could have started by treating it as a group based on the plus operator. So we have axioms:
211+- for all x,y : ``x+y=y+x``
212+- for all x: ``x + 0 = x = 0 + x``
213+- for all x,y,z: ``(x + y) + z = x + (x + z)``
215+Then we can implement '+' so that it respects these axioms (presumably implemented in hardware).
217+These are axioms, that is a propositions/types that are asserted to be true without proof. In Idris we can use the 'postulate' keyword
220+.. code-block:: idris
222+ postulate commutePlus: (x:Nat) -> (y:Nat) -> plus x y = plus y x
224+Alternatively we could define the natural numbers based on Zero and Successor. The axioms above then become derived rules and we also gain the ability to do inductive proofs.
226+As we know, Idris uses both of these approaches with automatic coercion between them which gives the best of both worlds.
228+So what can we learn from this to implement our own types:
230+- Should we try to implement both approaches?
231+- Should we define our types by constructing up from primitive types?
233+Proof theory affects these design decisions.
docs/proofs/index.rst+5−2
@@ -4,7 +4,7 @@
4Theorem Proving
4Theorem Proving
5###############
5###############
7−A tutorial on theorem proving in Idris.
7+A tutorial on theorem proving in Idris.
@@ -13,13 +13,16 @@ A tutorial on theorem proving in Idris.
13 Idris Community* has waived all copyright and related or neighboring
13 Idris Community* has waived all copyright and related or neighboring
14 rights to Documentation for Idris.
14 rights to Documentation for Idris.
16− More information concerning the CC0 can be found online at: http://creativecommons.org/publicdomain/zero/1.0/
16+ More information concerning the CC0 can be found online at: https://creativecommons.org/publicdomain/zero/1.0/
18.. toctree::
18.. toctree::
19 :maxdepth: 1
19 :maxdepth: 1
24 interactive
26 interactive
docs/proofs/inductive.rst+3−1
@@ -1,3 +1,5 @@
1****************
3****************
2Inductive Proofs
4Inductive Proofs
3****************
5****************
@@ -13,7 +15,7 @@ numbers. Recall that they are defined recursively, as follows:
13 S : Nat -> Nat
15 S : Nat -> Nat
15A *total* function over natural numbers must both terminate, and cover
17A *total* function over natural numbers must both terminate, and cover
16−all possible inputs. Idris checks functions for totality by cheking that
18+all possible inputs. Idris checks functions for totality by checking that
17all inputs are covered, and that all recursive calls are on
19all inputs are covered, and that all recursive calls are on
18*structurally smaller* values (so recursion will always reach a base
20*structurally smaller* values (so recursion will always reach a base
19case). Recalling ``plus``:
21case). Recalling ``plus``:
docs/proofs/interactive.rst+223−92
@@ -2,10 +2,101 @@
2Interactive Theorem Proving
2Interactive Theorem Proving
3***************************
3***************************
5−Idris also supports interactive theorem proving via tactics. This
5+Idris supports interactive theorem proving via elaborator reflection.
6−is generally not recommended to be used directly, but rather used as a
6+
7−mechanism for building proof automation which is beyond the scope of this
7+:ref:`elaborator-reflection` is also used to convert high-level Idris code into
8−tutorial. In this section, we briefly discus tactics.
8+the core language and for customising the language. Here we show how to use it
9+to interactively construct proofs.
11+The primary purpose of the elaboration mechanism is to elaborate Idris and so it
12+is not optimised to work as a proof assistant, however it can interactively
13+construct proofs as described on this page.
15+Elab and Pruviloj Libraries
16+===========================
18+Elaborator reflection is defined in ``prelude/Language/Reflection/Elab.idr``
19+and ``pruviloj`` is defined in ``Idris-dev/libs/pruviloj/``.
21+``Elab`` defines the basics such as: ``solve``, ``attack``, ``intro``, ``compute``,
22+``rewriteWith`` and others.
23+``pruviloj`` defines some more advanced derived commands such as:
24+``reflexivity`` and others.
26+To use ``pruviloj`` call Idris with the ``-p pruviloj`` option and add:
31+ import Pruviloj.Induction
33+to the top of your file.
35+It is useful to get the docs at the REPL by using the ``:doc`` command, and
36+search the docstrings using ``:apropos``. So to introduce the functions from
37+``Elab`` and ``Pruviloj``, that we will need for the following example, here are
42+ *plusReducesZ> :doc solve
43+ Language.Reflection.Elab.Tactics.solve : Elab ()
44+ Substitute a guess into a hole.
48+ *plusReducesZ> :doc attack
49+ Language.Reflection.Elab.Tactics.attack : Elab ()
50+ Convert a hole to make it suitable for bindings - that is, transform
51+ it such that it has the form ?h : t . h as opposed to ?h : t . f h.
53+ The binding tactics require that a hole be directly under its binding,
54+ or else the scopes of the generated terms won't make sense. This
55+ tactic creates a new hole of the proper form, and points the old hole
60+ *plusReducesZ> :doc intro
61+ Language.Reflection.Elab.Tactics.intro : (n : TTName) -> Elab ()
62+ Introduce a lambda binding around the current hole and focus on the
63+ body. Requires that the hole be in binding form (use attack).
65+ n : TTName -- the name to use for the argument
69+ *plusReducesZ> :doc compute
70+ Language.Reflection.Elab.Tactics.compute : Elab ()
75+ *plusReducesZ> :doc rewriteWith
76+ Language.Reflection.Elab.Tactics.rewriteWith : Raw -> Elab ()
77+ Attempt to rewrite the goal using an equality.
79+ The tactic searches the goal for applicable subterms, and constructs a
80+ context for replace using them. In some cases, this is not possible,
81+ and replace must be called manually with an appropriate context.
83+ Because this tactic internally introduces a let binding, it requires
84+ that the hole be immediately under its binder (use attack if it might
87+Here is the command from ``pruviloj`` that we will need for the example on
92+ *plusReducesZ> :doc reflexivity
93+ Pruviloj.Core.reflexivity : Elab ()
94+ A special-purpose tactic that attempts to solve a goal using Refl.
95+ This is useful for ensuring that goals in fact are trivial when
96+ developing or testing other tactics; otherwise, consider using search.
98+Interactive Example: plusReduces
99+================================
10One way to write proofs interactively is to write the general *structure* of
101One way to write proofs interactively is to write the general *structure* of
11the proof, and use the interactive mode to complete the details.
102the proof, and use the interactive mode to complete the details.
@@ -17,149 +108,189 @@ Consider the following definition, proved in :ref:`sect-theorems`:
18We’ll be constructing the proof by *induction*, so we write the cases for ``Z``
109We’ll be constructing the proof by *induction*, so we write the cases for ``Z``
19and ``S``, with a recursive call in the ``S`` case giving the inductive
110and ``S``, with a recursive call in the ``S`` case giving the inductive
20−hypothesis, and insert *metavariables* for the rest of the definition:
111+hypothesis, and insert *holes* for the rest of the definition:
22.. code-block:: idris
113.. code-block:: idris
116+ import Pruviloj.Induction
24 plusReducesZ' : (n:Nat) -> n = plus n Z
118 plusReducesZ' : (n:Nat) -> n = plus n Z
25 plusReducesZ' Z = ?plusredZ_Z
119 plusReducesZ' Z = ?plusredZ_Z
26 plusReducesZ' (S k) = let ih = plusReducesZ' k in
120 plusReducesZ' (S k) = let ih = plusReducesZ' k in
27 ?plusredZ_S
121 ?plusredZ_S
29On running , two global names are created, ``plusredZ_Z`` and
123On running , two global names are created, ``plusredZ_Z`` and
30−``plusredZ_S``, with no definition. We can use the ``:m`` command at the
124+``plusredZ_S``, with no definition.
31−prompt to find out which metavariables are still to be solved (or, more
32−precisely, which functions exist but have no definitions), then the
33−``:t`` command to see their types:
35.. code-block:: idris
126.. code-block:: idris
37− *theorems> :m
128+ *theorems> : idris plusReducesZ.idr -p pruviloj
38− Global metavariables:
39− [plusredZ_S,plusredZ_Z]
41−.. code-block:: idris
130+ . / _/___/ /____(_)____
131+ / // __ / ___/ / ___/ Version 1.2.0
132+ _/ // /_/ / / / (__ ) https://www.idris-lang.org/
133+ /___/\__,_/_/ /_/____/ Type :? for help
43− *theorems> :t plusredZ_Z
135+ Idris is free software with ABSOLUTELY NO WARRANTY.
44− plusredZ_Z : Z = plus Z Z
136+ For details type :warranty.
137+ Holes: Main.plusredZ_S, Main.plusredZ_Z
46− *theorems> :t plusredZ_S
139+This tells us that we have two holes ``Main.plusredZ_S`` and ``Main.plusredZ_Z``. We can solve
47− plusredZ_S : (k : Nat) -> (k = plus k Z) -> S k = plus (S k) Z
140+these separately, ``plusredZ_Z`` is the simplest so we will do that first.
49−The ``:p`` command enters interactive proof mode, which can be used to
142+The ``:elab plusredZ_Z`` command enters interactive elaboration mode, which can be used to
50−complete the missing definitions.
143+complete the missing definition for ``plusredZ_Z``.
52.. code-block:: idris
145.. code-block:: idris
54− *theorems> :p plusredZ_Z
147+ *plusReducesZ> :elab plusredZ_Z
56− ---------------------------------- (plusredZ_Z) --------
149+ ---------- Goal: ----------
57− {hole0} : Z = plus Z Z
150+ {hole_0} : 0 = 0
59−This gives us a list of premises (above the line; there are none here)
152+This has been normalised to ``0 = 0`` so now we have to prove that ``0`` equals ``0``, which
60−and the current goal (below the line; named ``{hole0}`` here). At the
153+is easy to prove by ``reflexivity`` from the ``pruviloj`` library:
61−prompt we can enter tactics to direct the construction of the proof. In
62−this case, we can normalise the goal with the ``compute`` tactic:
64.. code-block:: idris
155.. code-block:: idris
66− -plusredZ_Z> compute
157+ -Main.plusredZ_Z> reflexivity
68− ---------------------------------- (plusredZ_Z) --------
158+ plusredZ_Z: No more goals.
71−Now we have to prove that ``Z`` equals ``Z``, which is easy to prove by
160+This tells us that the proof is complete. We can now leave the interactive mode which
72−``Refl``. To apply a function, such as ``Refl``, we use ``refine`` which
161+we entered with the ``:elab`` command. We do this with the ``:qed`` command:
73−introduces subgoals for each of the function’s explicit arguments
76.. code-block:: idris
163.. code-block:: idris
78− -plusredZ_Z> refine Refl
165+ -Main.plusredZ_Z> :qed
79− plusredZ_Z: no more goals
166+ Proof completed!
167+ Main.plusredZ_Z = %runElab (do reflexivity)
168+ Holes: Main.plusredZ_S
81−Here, we could also have used the ``trivial`` tactic, which tries to
170+This gives us a trace of the proof which is ``plusredZ_Z = %runElab (do reflexivity)``. We
82−refine by ``Refl``, and if that fails, tries to refine by each name in
171+can cut & paste this into the hole in the original file. This also tells us that we
83−the local context. When a proof is complete, we use the ``qed`` tactic
172+have another hole ``Main.plusredZ_S`` remaining.
84−to add the proof to the global context, and remove the metavariable from
85−the unsolved metavariables list. This also outputs a trace of the proof:
87−.. code-block:: idris
174+This remaining proof is bit more complicated, the following diagram gives an overview:
96− *theorems> :m
176+|image|
97− Global metavariables:
100−The ``:addproof`` command, at the interactive prompt, will add the proof
178+We approach this remaining proof in the same way by using the ``:elab`` command:
101−to the source file (effectively in an appendix). Let us now prove the
102−other required lemma, ``plusredZ_S``:
104.. code-block:: idris
180.. code-block:: idris
106− *theorems> :p plusredZ_S
182+ *plusReducesZ> :elab plusredZ_S
108− ---------------------------------- (plusredZ_S) --------
184+
185+ ---------- Goal: ----------
109− {hole0} : (k : Nat) -> (k = plus k Z) -> S k = plus (S k) Z
186+ {hole_0} : (k : Nat) -> (k = plus k 0) -> S k = S (plus k 0)
111In this case, the goal is a function type, using ``k`` (the argument
188In this case, the goal is a function type, using ``k`` (the argument
112accessible by pattern matching) and ``ih`` — the local variable
189accessible by pattern matching) and ``ih`` — the local variable
113containing the result of the recursive call. We can introduce these as
190containing the result of the recursive call. We can introduce these as
114−premisses using the ``intro`` tactic twice (or ``intros``, which
191+assumptions using the ``intro`` tactic twice. The parameter is entered as
115−introduces all arguments as premisses). This gives:
192+a constant of type ``TTName`` which is entered as a backtick with double
193+braces ```{{ih}}``. This gives:
117.. code-block:: idris
195.. code-block:: idris
197+ -Main.plusredZ_S> intro `{{k}}
199+ ---------- Assumptions: ----------
120− ih : k = plus k Z
201+ ---------- Goal: ----------
121− ---------------------------------- (plusredZ_S) --------
202+ {hole_0} : (k = plus k 0) -> S k = S (plus k 0)
122− {hole2} : S k = plus (S k) Z
203+ -Main.plusredZ_S> intro `{{ih}}
205+ ---------- Assumptions: ----------
208+ ---------- Goal: ----------
209+ {hole_0} : S k = S (plus k 0)
124−Since plus is defined by recursion on its first argument, the term
211+We know, from the type of ``ih``, that ``k = plus k 0``, so we would
125−``plus (S k) Z`` in the goal can be simplified, so we use ``compute``.
212+like to use this knowledge to replace ``plus k 0`` in the goal with
213+``k``. We can achieve this with the ``rewriteWith`` tactic:
127.. code-block:: idris
215.. code-block:: idris
129− k : Nat
217+ -Main.plusredZ_S> rewriteWith (Var `{{ih}})
131− ---------------------------------- (plusredZ_S) --------
132− {hole2} : S k = S (plus k Z)
134−We know, from the type of ``ih``, that ``k = plus k Z``, so we would
219+ ---------- Assumptions: ----------
135−like to use this knowledge to replace ``plus k Z`` in the goal with
220+ k : Nat
136−``k``. We can achieve this with the ``rewrite`` tactic:
221+ ih : k = plus k 0
222+ ---------- Goal: ----------
223+ {hole_0} : S k = S k
225+The ``rewriteWith`` tactic takes an equality proof as an argument, and tries
226+to rewrite the goal using that proof. The ``ih`` value is entered as a constant
227+of type ``TTName`` which is entered as a backtick with double braces ```{{ih}}`` but
228+``rewriteWith`` requires an expression of type ``Raw``, rather than just a name,
229+so the ``Var`` constructor is used to make a variable. Here, it results in an equality
230+which is trivially provable using ``reflexivity``:
138.. code-block:: idris
232.. code-block:: idris
140− -plusredZ_S> rewrite ih
234+ -Main.plusredZ_S> reflexivity
235+ plusredZ_S: No more goals.
236+ -Main.plusredZ_S> :qed
238+ Main.plusredZ_S = %runElab (do intro `{{k}}
240+ rewriteWith (Var `{{ih}})
243+We can't just cut & paste this into the hole in the original file like this:
245+.. code-block:: idris
248+ import Pruviloj.Induction
250+ %language ElabReflection
252+ plusReducesZ' : (n:Nat) -> n = plus n Z
253+ plusReducesZ' Z = %runElab (do reflexivity)
254+ plusReducesZ' (S k) = let ih = plusReducesZ' k in
255+ (%runElab (do intro `{{k}}
257+ rewriteWith (Var `{{ih}})
142− k : Nat
261+because this gives the following error:
144− ---------------------------------- (plusredZ_S) --------
147− -plusredZ_S>
263+.. code-block:: idris
265+ Idris> :load elabInteractiveEx2.idr
266+ elabInteractiveEx2.idr:10:32:
271+ expecting dependent type signature
149−The ``rewrite`` tactic takes an equality proof as an argument, and tries
273+However if we put the proof into a separate function like this:
150−to rewrite the goal using that proof. Here, it results in an equality
151−which is trivially provable:
153.. code-block:: idris
275.. code-block:: idris
155− -plusredZ_S> trivial
277+ import Pruviloj
156− plusredZ_S: no more goals
278+ import Pruviloj.Induction
280+ %language ElabReflection
282+ plusredZ_S : (k : Nat) -> (ih:(k = plus k Z)) -> (S k = S (plus k Z))
157− -plusredZ_S> qed
283+ plusredZ_S = %runElab (do intro `{{k}}
158− plusredZ_S = proof {
284+ intro `{{ih}}
159− intros;
285+ rewriteWith (Var `{{ih}})
160− rewrite ih;
286+ reflexivity)
162− }
288+ plusReducesZ' : (n:Nat) -> n = plus n Z
289+ plusReducesZ' Z = %runElab (do reflexivity)
290+ plusReducesZ' (S k) = let ih = plusReducesZ' k in plusredZ_S k ih
292+This then loads [#f1]_ .
294+.. [#f1] https://github.com/idris-lang/Idris-dev/issues/4556
164−Again, we can add this proof to the end of our source file using the
296+.. |image| image:: ../image/plusReducesProof.png
165−``:addproof`` command at the interactive prompt.
docs/proofs/interactiveOld.rstnew file+169
@@ -0,0 +1,169 @@
1+**************************************************************
2+DEPRECATED: Interactive Theorem Proving Using Old Tactics Code
3+**************************************************************
6+ The interactive theorem-proving interface documented here has been
7+ deprecated in favor of :ref:`elaborator-reflection`.
9+Idris also supports interactive theorem proving via tactics. This
10+is generally not recommended to be used directly, but rather used as a
11+mechanism for building proof automation which is beyond the scope of this
12+tutorial. In this section, we briefly discus tactics.
14+One way to write proofs interactively is to write the general *structure* of
15+the proof, and use the interactive mode to complete the details.
16+Consider the following definition, proved in :ref:`sect-theorems`:
20+ plusReduces : (n:Nat) -> plus Z n = n
22+We’ll be constructing the proof by *induction*, so we write the cases for ``Z``
23+and ``S``, with a recursive call in the ``S`` case giving the inductive
24+hypothesis, and insert *holes* for the rest of the definition:
28+ plusReducesZ' : (n:Nat) -> n = plus n Z
29+ plusReducesZ' Z = ?plusredZ_Z
30+ plusReducesZ' (S k) = let ih = plusReducesZ' k in
33+On running , two global names are created, ``plusredZ_Z`` and
34+``plusredZ_S``, with no definition. We can use the ``:m`` command at the
35+prompt to find out which holes are still to be solved (or, more
36+precisely, which functions exist but have no definitions), then the
37+``:t`` command to see their types:
43+ [plusredZ_S,plusredZ_Z]
47+ *theorems> :t plusredZ_Z
48+ plusredZ_Z : Z = plus Z Z
50+ *theorems> :t plusredZ_S
51+ plusredZ_S : (k : Nat) -> (k = plus k Z) -> S k = plus (S k) Z
53+The ``:p`` command enters interactive proof mode, which can be used to
54+complete the missing definitions.
58+ *theorems> :p plusredZ_Z
60+ ---------------------------------- (plusredZ_Z) --------
61+ {hole0} : Z = plus Z Z
63+This gives us a list of premises (above the line; there are none here)
64+and the current goal (below the line; named ``{hole0}`` here). At the
65+prompt we can enter tactics to direct the construction of the proof. In
66+this case, we can normalise the goal with the ``compute`` tactic:
72+ ---------------------------------- (plusredZ_Z) --------
75+Now we have to prove that ``Z`` equals ``Z``, which is easy to prove by
76+``Refl``. To apply a function, such as ``Refl``, we use ``refine`` which
77+introduces subgoals for each of the function’s explicit arguments
82+ -plusredZ_Z> refine Refl
83+ plusredZ_Z: no more goals
85+Here, we could also have used the ``trivial`` tactic, which tries to
86+refine by ``Refl``, and if that fails, tries to refine by each name in
87+the local context. When a proof is complete, we use the ``qed`` tactic
88+to add the proof to the global context, and remove the hole from the
89+unsolved holes list. This also outputs a trace of the proof:
104+The ``:addproof`` command, at the interactive prompt, will add the proof
105+to the source file (effectively in an appendix). Let us now prove the
106+other required lemma, ``plusredZ_S``:
108+.. code-block:: idris
110+ *theorems> :p plusredZ_S
112+ ---------------------------------- (plusredZ_S) --------
113+ {hole0} : (k : Nat) -> (k = plus k Z) -> S k = plus (S k) Z
115+In this case, the goal is a function type, using ``k`` (the argument
116+accessible by pattern matching) and ``ih`` — the local variable
117+containing the result of the recursive call. We can introduce these as
118+premises using the ``intro`` tactic twice (or ``intros``, which
119+introduces all arguments as premises). This gives:
121+.. code-block:: idris
125+ ---------------------------------- (plusredZ_S) --------
126+ {hole2} : S k = plus (S k) Z
128+Since plus is defined by recursion on its first argument, the term
129+``plus (S k) Z`` in the goal can be simplified, so we use ``compute``.
131+.. code-block:: idris
135+ ---------------------------------- (plusredZ_S) --------
136+ {hole2} : S k = S (plus k Z)
138+We know, from the type of ``ih``, that ``k = plus k Z``, so we would
139+like to use this knowledge to replace ``plus k Z`` in the goal with
140+``k``. We can achieve this with the ``rewrite`` tactic:
142+.. code-block:: idris
144+ -plusredZ_S> rewrite ih
148+ ---------------------------------- (plusredZ_S) --------
153+The ``rewrite`` tactic takes an equality proof as an argument, and tries
154+to rewrite the goal using that proof. Here, it results in an equality
155+which is trivially provable:
157+.. code-block:: idris
159+ -plusredZ_S> trivial
160+ plusredZ_S: no more goals
162+ plusredZ_S = proof {
168+Again, we can add this proof to the end of our source file using the
169+``:addproof`` command at the interactive prompt.
docs/proofs/patterns.rst+9−9
@@ -14,13 +14,13 @@ mapping to Emacs commands.
14+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
14+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
15|Command | Vim binding | Emacs binding | Explanation |
15|Command | Vim binding | Emacs binding | Explanation |
16+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
16+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
17−| Check type | ``\t`` | ``C-c C-t`` | Show type of identifier or metavariable under the cursor. |
17+| Check type | ``\t`` | ``C-c C-t`` | Show type of identifier or hole under the cursor. |
18+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
18+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
19−| Proof search | ``\o`` | ``C-c C-a`` | Attempt to solve metavariable under the cursor by applying simple proof search. |
19+| Proof search | ``\o`` | ``C-c C-a`` | Attempt to solve hole under the cursor by applying simple proof search. |
20+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
20+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
21| Make new definition | ``\d`` | ``C-c C-s`` | Add a template definition for the type defined under the cursor. |
21| Make new definition | ``\d`` | ``C-c C-s`` | Add a template definition for the type defined under the cursor. |
22+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
22+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
23−| Make lemma | ``\l`` | ``C-c C-e`` | Add a top level function with a type which solves the metavariable under the cursor. |
23+| Make lemma | ``\l`` | ``C-c C-e`` | Add a top level function with a type which solves the hole under the cursor. |
24+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
24+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
25| Split cases | ``\c`` | ``C-c C-c`` | Create new constructor patterns for each possible case of the variable under the cursor. |
25| Split cases | ``\c`` | ``C-c C-c`` | Create new constructor patterns for each possible case of the variable under the cursor. |
26+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
26+---------------------+-----------------+---------------+--------------------------------------------------------------------------------------------+
@@ -56,7 +56,7 @@ should see:
56 plus_commutes Z m = ?plus_commutes_rhs_1
56 plus_commutes Z m = ?plus_commutes_rhs_1
57 plus_commutes (S k) m = ?plus_commutes_rhs_2
57 plus_commutes (S k) m = ?plus_commutes_rhs_2
59−If we inspect the types of the newly created metavariables,
59+If we inspect the types of the newly created holes,
60``plus_commutes_rhs_1`` and ``plus_commutes_rhs_2``, we see that the
60``plus_commutes_rhs_1`` and ``plus_commutes_rhs_2``, we see that the
61type of each reflects that ``n`` has been refined to ``Z`` and ``S k``
61type of each reflects that ``n`` has been refined to ``Z`` and ``S k``
62in each respective case. Pressing ``\t`` over
62in each respective case. Pressing ``\t`` over
@@ -102,7 +102,7 @@ yields:
102 plus_commutes Z m = plus_commutes_Z
102 plus_commutes Z m = plus_commutes_Z
103 plus_commutes (S k) m = ?plus_commutes_S
103 plus_commutes (S k) m = ?plus_commutes_S
105−That is, the metavariable has been filled with a call to a top level
105+That is, the hole has been filled with a call to a top level
106function ``plus_commutes_Z``. The argument ``m`` has been made implicit
106function ``plus_commutes_Z``. The argument ``m`` has been made implicit
107because it can be inferred from context when it is applied.
107because it can be inferred from context when it is applied.
@@ -120,7 +120,7 @@ First, create a template definition with ``\d``:
120 plus_commutes_Z = ?plus_commutes_Z_rhs
120 plus_commutes_Z = ?plus_commutes_Z_rhs
122Since we are going to write this by induction on ``m``, which is
122Since we are going to write this by induction on ``m``, which is
123−implciit, we will need to bring ``m`` into scope manually:
123+implicit, we will need to bring ``m`` into scope manually:
125.. code-block:: idris
125.. code-block:: idris
@@ -181,8 +181,8 @@ For ``plus_commutes_Z_rhs_2``, we now see:
181 --------------------------------------
181 --------------------------------------
182 plus_commutes_Z_rhs_2 : S k = S (plus k 0)
182 plus_commutes_Z_rhs_2 : S k = S (plus k 0)
184−Again, the ``fromInteger 0`` is merely due to ``Nat`` being an instance
184+Again, the ``fromInteger 0`` is merely due to ``Nat`` having an implementation
185−of the ``Num`` typeclass. So we know that ``k = plus k 0``, but how do
185+of the ``Num`` interface. So we know that ``k = plus k 0``, but how do
186we use this to update the goal to ``S k = S k``?
186we use this to update the goal to ``S k = S k``?
188To achieve this, Idris provides a ``replace`` function as part of the
188To achieve this, Idris provides a ``replace`` function as part of the
@@ -334,7 +334,7 @@ defined by matching on its first argument. The complete definition is:
334 plus_commutes_S k Z = Refl
334 plus_commutes_S k Z = Refl
335 plus_commutes_S k (S j) = rewrite plus_commutes_S k j in Refl
335 plus_commutes_S k (S j) = rewrite plus_commutes_S k j in Refl
337−All metavariables have now been solved.
337+All holes have now been solved.
339The ``total`` annotation means that we require the final function to
339The ``total`` annotation means that we require the final function to
340pass the totality checker; i.e. it will terminate on all possible
340pass the totality checker; i.e. it will terminate on all possible
docs/proofs/pluscomm.rst+5−5
@@ -53,7 +53,7 @@ as follows:
53.. code-block:: idris
53.. code-block:: idris
55 data (=) : a -> b -> Type where
55 data (=) : a -> b -> Type where
56− Refl : x = x
56+ Refl : x = x
58Note that this must be built-in, rather than defined in the library,
58Note that this must be built-in, rather than defined in the library,
59because ``=`` is a reserved operator — you cannot define this directly
59because ``=`` is a reserved operator — you cannot define this directly
@@ -88,9 +88,9 @@ error:
90 When elaborating right hand side of four_eq_five:
90 When elaborating right hand side of four_eq_five:
91− Can't unify
91+ Type mismatch between
92 x = x (Type of Refl)
92 x = x (Type of Refl)
94 4 = 5 (Expected type)
94 4 = 5 (Expected type)
96Type checking equality proofs
96Type checking equality proofs
@@ -177,12 +177,12 @@ given above as Idris type declarations:
178Both of these properties (and many others) are proved for natural number
178Both of these properties (and many others) are proved for natural number
179addition in the Idris standard library, using ``(+)`` from the ``Num``
179addition in the Idris standard library, using ``(+)`` from the ``Num``
180−type class rather than using ``plus`` directly. They have the names
180+interface rather than using ``plus`` directly. They have the names
181``plusCommutative`` and ``plusAssociative`` respectively.
181``plusCommutative`` and ``plusAssociative`` respectively.
183In the remainder of this tutorial, we will explore several different
183In the remainder of this tutorial, we will explore several different
184ways of proving ``plus_commutes`` (or, to put it another way, writing
184ways of proving ``plus_commutes`` (or, to put it another way, writing
185−the function.) We will also discuss how to use such equality proofs, and
185+the function). We will also discuss how to use such equality proofs, and
186see where the need for them arises in practice.
186see where the need for them arises in practice.
docs/proofs/propositional.rstnew file+133
@@ -0,0 +1,133 @@
1+******************************
2+Proving Propositional Equality
3+******************************
5+This page attempts to explain some of the techniques used in Idris to prove propositional equalities.
7+We have seen that definitional equalities can be proved using ``Refl`` since they always normalise to unique values that can be compared directly.
9+However with propositional equalities we are using symbolic variables they do not always normalise.
11+So to take the previous example:
15+ plusReducesR : (n:Nat) -> plus n Z = n
17+In this case ``plus n Z`` does not normalise to ``n``. Even though both sides are equal we cannot pattern match ``Refl``.
19+If the pattern match cannot match for all ``n`` then the way around this is to separately match all possible values of ``n``. In the case of natural numbers we do this by induction.
25+ plusReducesR : n = plus n 0
26+ plusReducesR {n = Z} = Refl
27+ plusReducesR {n = (S k)} = let rec = plus_commutes_Z {n=k} in
30+we don't call ``Refl`` to match on ``n = plus n 0`` forall ``n`` we call it for every number separately. So, in the second line, the pattern matcher knows to substitute ``Z`` for ``n`` in the type being matched. This uses ``rewrite`` which is explained below.
35+This implements the *indiscernability of identicals* principle, if two terms are equal then they have the same properties. In other words, if ``x=y``, then we can substitute ``y`` for ``x`` in any expression. In our proofs we can express this as:
42+where ``P`` is a pure function representing the property. In the examples below ``P`` is an expression in some variable with a type like this: ``P: n -> Type``.
44+So if ``n`` is a natural number variable then ``P`` could be something like ``2*n + 3``.
46+To use this in our proofs there is the following function in the prelude:
50+ ||| Perform substitution in a term according to some equality.
51+ replace : {a:_} -> {x:_} -> {y:_} -> {P : a -> Type} -> x = y -> P x -> P y
52+ replace Refl prf = prf
54+Removing the implicits, if we supply an equality ``x=y`` and a proof of a property of ``x`` (i.e. ``P x``) then we get a proof of a property of ``y`` (i.e. ``P y``)
59+ replace : (x = y) -> P x -> P y
61+So, in the following example, if we supply ``p1 x`` which is a proof that ``x=2`` and the equality ``x=y`` then we get a proof that ``y=2``.
68+ testReplace: (x=y) -> (p1 x) -> (p1 y)
69+ testReplace a b = replace a b
74+Similar to ``replace`` above but Idris provides a nicer syntax which makes ``rewrite`` easier to use in examples like ``plusReducesR`` above.
78+ rewrite__impl : (P : a -> Type) -> x = y -> P y -> P x
79+ rewrite__impl p Refl prf = prf
81+The difference from ``replace`` above is nicer syntax and the property ``p1`` is explicitly supplied and it goes in the opposite direction (input and output reversed).
83+Example: again we supply ``p1`` which is a proof that ``x=2`` and the equality ``x=y`` then we get a proof that ``y=2``.
90+ testRewrite2: (x=y) -> (p1 y) -> (p1 x)
91+ testRewrite2 a b = rewrite a in b
93+We can think of rewrite doing this:
95+ * start with a equation ``x=y`` and a property ``P: x -> Type``;
96+ * search ``y`` in ``P``;
97+ * replace all occurrences of ``y`` with ``x`` in ``P``.
99+That is, we are doing a substitution.
101+Symmetry and Transitivity
102+=========================
104+In addition to *reflexivity* equality also obeys *symmetry* and *transitivity* and these are also included in the prelude:
106+.. code-block:: idris
108+ ||| Symmetry of propositional equality
109+ sym : {left:a} -> {right:b} -> left = right -> right = left
112+ ||| Transitivity of propositional equality
113+ trans : {a:x} -> {b:y} -> {c:z} -> a = b -> b = c -> a = c
114+ trans Refl Refl = Refl
116+Heterogeneous Equality
117+======================
119+Also included in the prelude:
121+.. code-block:: idris
123+ ||| Explicit heterogeneous ("John Major") equality. Use this when Idris
124+ ||| incorrectly chooses homogeneous equality for `(=)`.
125+ ||| @ a the type of the left side
126+ ||| @ b the type of the right side
127+ ||| @ x the left side
128+ ||| @ y the right side
129+ (~=~) : (x : a) -> (y : b) -> Type
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.rst+12−5
This diff is too big to show here.
docs/reference/erasure.rst+10−10
This diff is too big to show here.
docs/reference/ffi.rst+272−17
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.rst+16−1
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.rst+6−6
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.rst+6−6
This diff is too big to show here.
docs/tutorial/index.rst+6−3
This diff is too big to show here.
docs/tutorial/interactive.rst+14−15
This diff is too big to show here.
docs/tutorial/classes.rst → docs/tutorial/interfaces.rstrenamed+221−105
This diff is too big to show here.
docs/tutorial/interp.rst+29−17
This diff is too big to show here.
docs/tutorial/introduction.rst+10−5
This diff is too big to show here.
docs/tutorial/miscellany.rst+69−26
This diff is too big to show here.
docs/tutorial/modules.rst+87−56
This diff is too big to show here.
docs/tutorial/packages.rst+151−43
This diff is too big to show here.
docs/tutorial/provisional.rst+29−20
This diff is too big to show here.
docs/tutorial/starting.rst+12−5
This diff is too big to show here.
docs/tutorial/syntax.rst+17−17
This diff is too big to show here.
docs/tutorial/theorems.rst+146−7
This diff is too big to show here.
docs/tutorial/typesfuns.rst+481−222
This diff is too big to show here.
docs/tutorial/views.rst+77−19
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.
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−14
This diff is too big to show here.
jsrts/Runtime-common.js+21−102
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+38−15
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−1238
This diff is too big to show here.
This diff is too big to show here.
libs/base/Control/Arrow.idr+19−19
This diff is too big to show here.
libs/base/Control/Catchable.idr+35−10
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+38−29
This diff is too big to show here.
libs/base/Control/Monad/Identity.idr+26−5
This diff is too big to show here.
libs/base/Control/Monad/RWS.idr+27−21
This diff is too big to show here.
libs/base/Control/Monad/Reader.idr+10−10
This diff is too big to show here.
libs/base/Control/Monad/State.idr+29−25
This diff is too big to show here.
libs/base/Control/Monad/Trans.idr+3−1
This diff is too big to show here.
libs/base/Control/Monad/Writer.idr+19−16
This diff is too big to show here.
libs/base/Data/Bits.idr+163−92
This diff is too big to show here.
libs/base/Data/Buffer.idrnew file+170
This diff is too big to show here.
libs/base/Data/Complex.idr+32−26
This diff is too big to show here.
libs/base/Data/Erased.idr+4−4
This diff is too big to show here.
libs/base/Data/Fin.idr+35−31
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/HVect.idr+35−18
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.idr+36−13
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+14−16
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/So.idr+13−2
This diff is too big to show here.
libs/base/Data/SortedSet.idrdeleted−28
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+1011−9
This diff is too big to show here.
libs/base/Data/Vect/Quantifiers.idr+4−1
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/VectType.idrdeleted−596
This diff is too big to show here.
libs/base/Debug/Error.idr+5−8
This diff is too big to show here.
libs/base/Debug/Trace.idr+2−1
This diff is too big to show here.
libs/base/Language/Reflection/Utils.idr+246−174
This diff is too big to show here.
This diff is too big to show here.
libs/base/Syntax/PreorderReasoning.idr+2
This diff is too big to show here.
libs/base/System.idr+60−29
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/Raw.idr+84−41
This diff is too big to show here.
libs/base/System/Info.idr+3
This diff is too big to show here.
libs/base/base.ipkg+51−29
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/Classes/Verified.idrdeleted−117
This diff is too big to show here.
libs/contrib/Control/Algebra.idr+31−16
This diff is too big to show here.
libs/contrib/Control/Algebra/Lattice.idr+28−11
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/NumericInstances.idrdeleted−104
This diff is too big to show here.
libs/contrib/Control/Algebra/VectorSpace.idr+5−3
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/contrib/Control/Isomorphism/Primitives.idr+1−1
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.idr+1−1
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.idr+32−3
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.idr+6−6
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.idr+2−1
This diff is too big to show here.
libs/contrib/Data/Hash.idr+16−16
This diff is too big to show here.
libs/contrib/Data/Heap.idr+20−34
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.idr+33−124
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.idr+17−158
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/PosNat.idrnew file+57
This diff is too big to show here.
libs/contrib/Data/Rel.idr+1
This diff is too big to show here.
libs/contrib/Data/Sign.idr+32−1
This diff is too big to show here.
libs/contrib/Data/SortedBag.idrnew file+127
This diff is too big to show here.
libs/contrib/Data/SortedMap.idr+74−11
This diff is too big to show here.
libs/contrib/Data/SortedSet.idr+41−10
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.idrdeleted−31
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.idr+229−28
This diff is too big to show here.
libs/contrib/Decidable/Decidable.idr+4−4
This diff is too big to show here.
libs/contrib/Decidable/Order.idr+17−17
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/Makefile+4−3
This diff is too big to show here.
libs/contrib/Network/Cgi.idr+32−30
This diff is too big to show here.
libs/contrib/Network/Socket.idr+195−317
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.idr+32−18
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.ipkg+111−22
This diff is too big to show here.
libs/effects/Effect/Default.idr+16−15
This diff is too big to show here.
libs/effects/Effect/Exception.idr+9−7
This diff is too big to show here.
libs/effects/Effect/File.idr+411−130
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+15−9
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+34−16
This diff is too big to show here.
libs/effects/Effect/Select.idr+4−2
This diff is too big to show here.
libs/effects/Effect/State.idr+3−3
This diff is too big to show here.
libs/effects/Effect/StdIO.idr+4−2
This diff is too big to show here.
libs/effects/Effect/System.idr+13−4
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+174−89
This diff is too big to show here.
libs/effects/Makefile+2−1
This diff is too big to show here.
libs/effects/effects.ipkg+19−5
This diff is too big to show here.
libs/oldeffects/Effect/Default.idrdeleted−44
This diff is too big to show here.
libs/oldeffects/Effect/Exception.idrdeleted−41
This diff is too big to show here.
libs/oldeffects/Effect/File.idrdeleted−128
This diff is too big to show here.
libs/oldeffects/Effect/Memory.idrdeleted−175
This diff is too big to show here.
libs/oldeffects/Effect/Monad.idrdeleted−21
This diff is too big to show here.
libs/oldeffects/Effect/Random.idrdeleted−47
This diff is too big to show here.
libs/oldeffects/Effect/Select.idrdeleted−23
This diff is too big to show here.
libs/oldeffects/Effect/State.idrdeleted−40
This diff is too big to show here.
libs/oldeffects/Effect/StdIO.idrdeleted−60
This diff is too big to show here.
libs/oldeffects/Effect/System.idrdeleted−43
This diff is too big to show here.
libs/oldeffects/Effects.idrdeleted−333
This diff is too big to show here.
libs/oldeffects/effects.ipkgdeleted−9
This diff is too big to show here.
libs/prelude/Builtins.idr+109−50
This diff is too big to show here.
libs/prelude/Decidable/Equality.idr+83−37
This diff is too big to show here.
libs/prelude/IO.idr+176−52
This diff is too big to show here.
libs/prelude/Language/Reflection.idr+811−183
This diff is too big to show here.
libs/prelude/Language/Reflection/Elab.idr+600−156
This diff is too big to show here.
libs/prelude/Language/Reflection/Errors.idr+6−3
This diff is too big to show here.
libs/prelude/Makefile+3−2
This diff is too big to show here.
libs/prelude/Prelude.idr+134−373
This diff is too big to show here.
libs/prelude/Prelude/Algebra.idr+6−8
This diff is too big to show here.
libs/prelude/Prelude/Applicative.idr+37−7
This diff is too big to show here.
libs/prelude/Prelude/Basics.idr+11−10
This diff is too big to show here.
libs/prelude/Prelude/Bits.idr+87−30
This diff is too big to show here.
libs/prelude/Prelude/Bool.idr+15−3
This diff is too big to show here.
libs/prelude/Prelude/Cast.idr+22−14
This diff is too big to show here.
libs/prelude/Prelude/Chars.idr+16−6
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+16−6
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/Foldable.idr+26−6
This diff is too big to show here.
libs/prelude/Prelude/Functor.idr+24−13
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+153−132
This diff is too big to show here.
libs/prelude/Prelude/List.idr+264−184
This diff is too big to show here.
libs/prelude/Prelude/Maybe.idr+43−15
This diff is too big to show here.
libs/prelude/Prelude/Monad.idr+38−11
This diff is too big to show here.
libs/prelude/Prelude/Nat.idr+207−395
This diff is too big to show here.
libs/prelude/Prelude/Pairs.idr+8−8
This diff is too big to show here.
libs/prelude/Prelude/Providers.idr+7−5
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+23−23
This diff is too big to show here.
libs/prelude/Prelude/Strings.idr+132−42
This diff is too big to show here.
libs/prelude/Prelude/Traversable.idr+11−1
This diff is too big to show here.
libs/prelude/Prelude/Uninhabited.idr+4−2
This diff is too big to show here.
libs/contrib/Control/WellFounded.idr → libs/prelude/Prelude/WellFounded.idrrenamed+59−7
This diff is too big to show here.
libs/prelude/prelude.ipkg+36−10
This diff is too big to show here.
libs/oldeffects/Makefile → libs/pruviloj/Makefilerenamed+3−3
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.
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.
This diff is too big to show here.
This diff is too big to show here.
rts/idris_bitstring.c+284−517
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.
rts/idris_stdfgn.c+233−21
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/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/idris_net.cdeleted−196
This diff is too big to show here.
rts/windows/idris_stdfgn.cdeleted−82
This diff is too big to show here.
rts/windows/win_utils.c+49−3
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/Exception.idr+1−1
This diff is too big to show here.
samples/effects/TreeTag.idr+3−3
This diff is too big to show here.
samples/misc/binary.idr+2−2
This diff is too big to show here.
samples/misc/interp.idr+24−15
This diff is too big to show here.
samples/misc/named_instance.lidr → samples/misc/named_implementation.lidrrenamed+5−5
This diff is too big to show here.
samples/tutorial/bmain.idr → samples/tutorial/BMain.idrrenamed+2−2
This diff is too big to show here.
samples/tutorial/btree.idr → samples/tutorial/BTree.idrrenamed+4
This diff is too big to show here.
samples/tutorial/btreemod.idr → samples/tutorial/BTreeMod.idrrenamed+5−5
This diff is too big to show here.
samples/tutorial/foo.idr → samples/tutorial/Foo.idrrenamed
The content is the same.
samples/tutorial/hello.idr → samples/tutorial/Hello.idrrenamed
The content is the same.
samples/tutorial/idiom.idr → samples/tutorial/Idiom.idrrenamed+2−2
This diff is too big to show here.
samples/tutorial/classes.idr → samples/tutorial/Interfaces.idrrenamed+1−1
This diff is too big to show here.
samples/tutorial/interp.idr → samples/tutorial/Interp.idrrenamed+5−2
This diff is too big to show here.
samples/tutorial/letbind.idr → samples/tutorial/LetBind.idrrenamed+1−1
This diff is too big to show here.
samples/tutorial/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.idr → samples/tutorial/Theorems.idrrenamed−20
This diff is too big to show here.
samples/tutorial/universe.idr → samples/tutorial/Universe.idrrenamed
The content is the same.
samples/tutorial/usefultypes.idr → samples/tutorial/UsefulTypes.idrrenamed+1
This diff is too big to show here.
samples/tutorial/vbroken.idr → samples/tutorial/VBroken.idrrenamed
The content is the same.
samples/tutorial/views.idr → samples/tutorial/Views.idrrenamed+8−20
This diff is too big to show here.
samples/tutorial/viewsbroken.idr → samples/tutorial/ViewsBroken.idrrenamed
The content is the same.
samples/tutorial/wheres.idr → samples/tutorial/Wheres.idrrenamed+1−1
This diff is too big to show here.
samples/tutorial/binary.idrdeleted−61
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+39−36
This diff is too big to show here.
src/IRTS/CodegenC.hs+416−175
This diff is too big to show here.
src/IRTS/CodegenCommon.hs+35−30
This diff is too big to show here.
src/IRTS/CodegenJavaScript.hs+64−1358
This diff is too big to show here.
src/IRTS/Compiler.hs+340−247
This diff is too big to show here.
src/IRTS/Defunctionalise.hs+83−99
This diff is too big to show here.
This diff is too big to show here.
src/IRTS/Exports.hs+16−12
This diff is too big to show here.
This diff is too big to show here.
src/IRTS/JavaScript/AST.hs+282−394
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.hs+308−60
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+59−65
This diff is too big to show here.
This diff is too big to show here.
src/Idris/ASTUtils.hs+72−62
This diff is too big to show here.
src/Idris/AbsSyntax.hs+1029−579
This diff is too big to show here.
src/Idris/AbsSyntaxTree.hs+1624−1204
This diff is too big to show here.
src/Idris/Apropos.hs+16−14
This diff is too big to show here.
src/Idris/CaseSplit.hs+219−163
This diff is too big to show here.
src/Idris/Chaser.hs+192−100
This diff is too big to show here.
src/Idris/CmdOptions.hs+220−98
This diff is too big to show here.
src/Idris/Colours.hs+42−18
This diff is too big to show here.
src/Idris/Completion.hs+95−68
This diff is too big to show here.
src/Idris/Core/Binary.hs+70−351
This diff is too big to show here.
src/Idris/Core/CaseTree.hs+218−138
This diff is too big to show here.
src/Idris/Core/Constraints.hs+64−32
This diff is too big to show here.
src/Idris/Core/DeepSeq.hs+56−228
This diff is too big to show here.
src/Idris/Core/Elaborate.hs+289−178
This diff is too big to show here.
src/Idris/Core/Evaluate.hs+425−248
This diff is too big to show here.
src/Idris/Core/Execute.hs+172−89
This diff is too big to show here.
src/Idris/Core/ProofState.hs+253−272
This diff is too big to show here.
src/Idris/Core/ProofTerm.hs+72−70
This diff is too big to show here.
src/Idris/Core/TT.hs+515−335
This diff is too big to show here.
src/Idris/Core/Typecheck.hs+195−168
This diff is too big to show here.
src/Idris/Core/Unify.hs+250−266
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+427−727
This diff is too big to show here.
This diff is too big to show here.
src/Idris/DataOpts.hs+12−14
This diff is too big to show here.
src/Idris/DeepSeq.hs+89−377
This diff is too big to show here.
src/Idris/Delaborate.hs+349−190
This diff is too big to show here.
src/Idris/Directives.hs+107−42
This diff is too big to show here.
src/Idris/Docs.hs+236−128
This diff is too big to show here.
src/Idris/Docstrings.hs+30−23
This diff is too big to show here.
src/Idris/Elab/AsPat.hs+38−13
This diff is too big to show here.
src/Idris/Elab/Class.hsdeleted−294
This diff is too big to show here.
src/Idris/Elab/Clause.hs+623−361
This diff is too big to show here.
src/Idris/Elab/Data.hs+158−394
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/Instance.hsdeleted−332
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.hs+24−47
This diff is too big to show here.
src/Idris/ElabQuasiquote.hs → src/Idris/Elab/Quasiquote.hsrenamed+29−22
This diff is too big to show here.
src/Idris/Elab/Record.hs+149−159
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.hs+1353−944
This diff is too big to show here.
src/Idris/Elab/Transform.hs+38−57
This diff is too big to show here.
src/Idris/Elab/Type.hs+103−104
This diff is too big to show here.
src/Idris/Elab/Utils.hs+622−84
This diff is too big to show here.
src/Idris/Elab/Value.hs+47−55
This diff is too big to show here.
src/Idris/ElabDecls.hs+142−102
This diff is too big to show here.
src/Idris/Erasure.hs+198−80
This diff is too big to show here.
src/Idris/ErrReverse.hs+23−22
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/Idris/IBC.hs+806−1890
This diff is too big to show here.
src/Idris/IdeMode.hs+62−44
This diff is too big to show here.
src/Idris/IdrisDoc.hs+105−90
This diff is too big to show here.
src/Idris/Imports.hs+66−21
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+12−7
This diff is too big to show here.
src/Idris/Interactive.hs+269−119
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.hs+246−38
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/ParseExpr.hsdeleted−1430
This diff is too big to show here.
src/Idris/ParseHelpers.hsdeleted−641
This diff is too big to show here.
src/Idris/ParseOps.hsdeleted−173
This diff is too big to show here.
src/Idris/Parser.hs+1051−739
This diff is too big to show here.
src/Idris/ParseData.hs → src/Idris/Parser/Data.hsrenamed+115−137
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+192−107
This diff is too big to show here.
src/Idris/Primitives.hs+42−60
This diff is too big to show here.
src/Idris/ProofSearch.hs+342−79
This diff is too big to show here.
src/Idris/Prover.hs+386−176
This diff is too big to show here.
src/Idris/Providers.hs+17−9
This diff is too big to show here.
src/Idris/REPL.hs+469−801
This diff is too big to show here.
src/Idris/REPL/Browse.hs+15−7
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−471
This diff is too big to show here.
src/Idris/Reflection.hs+442−215
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+30−25
This diff is too big to show here.
src/Idris/TypeSearch.hs+155−131
This diff is too big to show here.
This diff is too big to show here.
src/Idris/WhoCalls.hs+10−5
This diff is too big to show here.
src/Pkg/PParser.hsdeleted−106
This diff is too big to show here.
src/Pkg/Package.hsdeleted−291
This diff is too big to show here.
src/Util/DynamicLinker.hs+103−28
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.
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.
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/expected → test/basic001/expected.outrenamed
The content is the same.
test/basic001/rundeleted−6
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+9−9
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/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/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/basic006/expecteddeleted−8
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−6
This diff is too big to show here.
test/basic006/run.shnew file+6
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/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/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−8
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.idr+13−13
This diff is too big to show here.
test/basic010/expected → test/basic010/expected.outrenamed+1−1
This diff is too big to show here.
test/basic010/rundeleted−41
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.idr+4
This diff is too big to show here.
test/basic011/expected → test/basic011/expected.outrenamed+4
This diff is too big to show here.
test/basic011/rundeleted−4
This diff is too big to show here.
test/basic011/run.shnew file+4
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 → test/basic012/expected.outrenamed
The content is the same.
test/basic012/rundeleted−4
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.idr+45−1
This diff is too big to show here.
test/basic013/expecteddeleted−14
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 → test/basic013/run.shrenamed+1−1
This diff is too big to show here.
test/basic014/basic014.idrnew file+44
This diff is too big to show here.
test/disambig002/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/bignum001/expected → test/basic020/expected.outrenamed
The content is the same.
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/expected.outnew file+1
This diff is too big to show here.
test/bignum001/run → test/bignum001/run.shrenamed+1−1
This diff is too big to show here.
test/bignum002/bignum002.idr+10−1
This diff is too big to show here.
test/bignum002/expecteddeleted−1
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 → test/bignum002/run.shrenamed+1−1
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/expected → test/bounded001/expected.outrenamed
The content is the same.
test/bounded001/run → test/bounded001/run.shrenamed+1−1
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/classes001/rundeleted−3
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.idr+1−1
This diff is too big to show here.
test/corecords001/expected → test/corecords001/expected.outrenamed
The content is the same.
test/corecords001/run → test/corecords001/run.shrenamed+1−1
This diff is too big to show here.
test/corecords002/expected → test/corecords002/expected.outrenamed
The content is the same.
test/corecords002/run → test/corecords002/run.shrenamed+1−1
This diff is too big to show here.
test/delab001/expected → test/delab001/expected.outrenamed+2−2
This diff is too big to show here.
test/delab001/input → test/delab001/input.inrenamed
The content is the same.
test/delab001/rundeleted−3
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/disambig001/disambig001.idrdeleted−12
This diff is too big to show here.
test/disambig001/expecteddeleted−1
This diff is too big to show here.
test/disambig001/rundeleted−4
This diff is too big to show here.
test/disambig002/disambig002.idr+13−18
This diff is too big to show here.
test/error002/expected → test/disambig002/expected.outrenamed
The content is the same.
test/disambig002/rundeleted−3
This diff is too big to show here.
test/disambig002/run.shnew file+3
This diff is too big to show here.
test/docs001/docs001.idr+7−7
This diff is too big to show here.
test/docs001/expecteddeleted−16
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 → test/docs001/input.inrenamed
The content is the same.
test/docs001/rundeleted−3
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.idr+2−2
This diff is too big to show here.
test/docs002/expecteddeleted−9
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 → test/docs002/input.inrenamed
The content is the same.
test/docs002/rundeleted−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.idr+2−2
This diff is too big to show here.
test/docs003/expecteddeleted−36
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 → test/docs003/input.inrenamed
The content is the same.
test/docs003/rundeleted−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/expecteddeleted−15
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 → test/docs004/input.inrenamed
The content is the same.
test/docs004/rundeleted−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+14−12
This diff is too big to show here.
test/dsl002/Resimp.idr+27−24
This diff is too big to show here.
test/dsl002/expected → test/dsl002/expected.outrenamed
The content is the same.
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+8−7
This diff is too big to show here.
test/dsl003/DSLPi.idr+3−1
This diff is too big to show here.
test/dsl003/expected → test/dsl003/expected.outrenamed+1−1
This diff is too big to show here.
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/ffi004/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+35−20
This diff is too big to show here.
test/effects001/test021a.idr+3−3
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+1−1
This diff is too big to show here.
test/effects003/VectMissing.idr+1−3
This diff is too big to show here.
test/effects003/expecteddeleted−41
This diff is too big to show here.
test/effects003/expected.outnew file+31
This diff is too big to show here.
This diff is too big to show here.
test/effects003/hangman.idr+8−4
This diff is too big to show here.
This diff is too big to show here.
test/effects003/input.in+6
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/effects004/expected.out
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.
test/effects005/categoryLogger.idr+23
This diff is too big to show here.
test/effects005/defaultLogger.idr+14
This diff is too big to show here.
test/effects005/expected.out+5
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/error001/expected.out+13
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/error002/expected.out
This diff is too big to show here.
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+3−3
This diff is too big to show here.
This diff is too big to show here.
test/error003/expected.out+9
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/error004/FunErrTest.idr+12−11
This diff is too big to show here.
This diff is too big to show here.
test/error004/expected.out+20
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/error005/expected−21
This diff is too big to show here.
test/error005/expected.out+56
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/error006/WithPatsNoWith.idr+17
This diff is too big to show here.
test/error006/expected.out+21
This diff is too big to show here.
This diff is too big to show here.
test/error007/error007.idr+29
This diff is too big to show here.
test/error007/expected.out+19
This diff is too big to show here.
This diff is too big to show here.
test/error008/error008.idr+5
This diff is too big to show here.
test/error008/error008a.idr+5
This diff is too big to show here.
test/error008/expected.out+14
This diff is too big to show here.
This diff is too big to show here.
test/error009/expected.out+1
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.
test/ffi001/test022.idr+2−2
This diff is too big to show here.
This diff is too big to show here.
test/ffi002/expected.out+6
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/ffi002/test023.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.
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.
test/ffi004/test026.idr+3−2
This diff is too big to show here.
test/ffi004/theOtherType+1−1
This diff is too big to show here.
test/ffi005/Postulate.idr+1−1
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.
test/ffi006/ffi006.idr+1−1
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/ffi007/expected.out+10
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/ffi007/ffi007.idr+63
This diff is too big to show here.
This diff is too big to show here.
test/ffi008/expected.out+5
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/ffi008/ffi008.idr+58
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.
test/ffi009/expected.out+1
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.
test/ffi010/expected.out+3
This diff is too big to show here.
test/ffi010/ffi010.idr+43
This diff is too big to show here.
This diff is too big to show here.
test/ffi011/expected.out+2
This diff is too big to show here.
test/ffi011/ffi011.idr+27
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/ffi012/expected.out+1
This diff is too big to show here.
test/ffi012/ffi012.idr+14
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/ffi013/expected.out+4
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/folding001/expected.out
This diff is too big to show here.
test/folding001/run.sh+1−1
This diff is too big to show here.
test/idrisdoc001/expected.out
This diff is too big to show here.
test/idrisdoc001/run.sh+1−1
This diff is too big to show here.
test/idrisdoc002/TestFunctions.idr+2−1
This diff is too big to show here.
test/idrisdoc002/expected.out
This diff is too big to show here.
test/idrisdoc002/run.sh+2−2
This diff is too big to show here.
test/idrisdoc003/TestDatatypes.idr+2−1
This diff is too big to show here.
test/idrisdoc003/expected.out
This diff is too big to show here.
test/idrisdoc003/run.sh+2−2
This diff is too big to show here.
test/idrisdoc004/TestInterfaces.idr+9
This diff is too big to show here.
test/idrisdoc004/TestTypeclasses.idr−8
This diff is too big to show here.
test/idrisdoc004/expected−1
This diff is too big to show here.
test/idrisdoc004/expected.out+1
This diff is too big to show here.
This diff is too big to show here.
test/idrisdoc004/run.sh+5
This diff is too big to show here.
test/idrisdoc004/test_interfaces.ipkg+6
This diff is too big to show here.
test/idrisdoc004/test_typeclasses.ipkg−6
This diff is too big to show here.
test/idrisdoc005/TestTracing.idr+2−1
This diff is too big to show here.
test/idrisdoc005/expected.out
This diff is too big to show here.
test/idrisdoc005/run.sh+2−2
This diff is too big to show here.
test/idrisdoc006/A/fully/Qualified/NAME.idr+2−2
This diff is too big to show here.
test/idrisdoc006/B.idr+2−1
This diff is too big to show here.
test/idrisdoc006/expected.out
This diff is too big to show here.
test/idrisdoc006/run.sh+3−3
This diff is too big to show here.
test/idrisdoc007/expected.out
This diff is too big to show here.
test/idrisdoc007/run.sh+2−2
This diff is too big to show here.
test/idrisdoc008/Abstract.idr+2−2
This diff is too big to show here.
test/idrisdoc008/Visible.idr+2−2
This diff is too big to show here.
test/idrisdoc008/expected.out
This diff is too big to show here.
test/idrisdoc008/run.sh+2−2
This diff is too big to show here.
test/idrisdoc009/Test.idr+2
This diff is too big to show here.
test/idrisdoc009/expected.out+3−1
This diff is too big to show here.
test/idrisdoc009/input.in
This diff is too big to show here.
This diff is too big to show here.
test/idrisdoc009/run.sh+3
This diff is too big to show here.
test/interactive001/expected−13
This diff is too big to show here.
test/interactive001/expected.out+20
This diff is too big to show here.
test/interactive001/input−6
This diff is too big to show here.
test/interactive001/input.in+8
This diff is too big to show here.
test/interactive001/interactive001.idr+9
This diff is too big to show here.
test/interactive001/run−3
This diff is too big to show here.
test/interactive001/run.sh+5
This diff is too big to show here.
test/interactive002/expected.out+1−1
This diff is too big to show here.
test/interactive002/input.in
This diff is too big to show here.
test/interactive002/run−3
This diff is too big to show here.
test/interactive002/run.sh+3
This diff is too big to show here.
test/interactive003/expected.out+1
This diff is too big to show here.
test/interactive003/input.in+1
This diff is too big to show here.
test/interactive003/interactive003.idr+5
This diff is too big to show here.
test/interactive003/run−3
This diff is too big to show here.
test/interactive003/run.sh+3
This diff is too big to show here.
test/interactive004/expected−2
This diff is too big to show here.
test/interactive004/expected.out+2
This diff is too big to show here.
test/interactive004/input.in
This diff is too big to show here.
test/interactive004/run−3
This diff is too big to show here.
test/interactive004/run.sh+3
This diff is too big to show here.
test/interactive005/expected.out+9−6
This diff is too big to show here.
test/interactive005/input.in
This diff is too big to show here.
test/interactive005/run−6
This diff is too big to show here.
test/interactive005/run.sh+6
This diff is too big to show here.
test/interactive006/expected.out
This diff is too big to show here.
test/interactive006/input.in
This diff is too big to show here.
test/interactive006/run−3
This diff is too big to show here.
test/interactive006/run.sh+3
This diff is too big to show here.
test/interactive007/expected.msys−1
This diff is too big to show here.
test/interactive007/expected.out
This diff is too big to show here.
test/interactive007/input.in
This diff is too big to show here.
test/interactive007/run−2
This diff is too big to show here.
test/interactive007/run.sh+2
This diff is too big to show here.
test/interactive008/expected.out+204
This diff is too big to show here.
test/interactive008/input.in+9
This diff is too big to show here.
test/interactive008/run.sh+2
This diff is too big to show here.
test/interactive009/expected.out+1
This diff is too big to show here.
test/interactive009/input.in+1
This diff is too big to show here.
test/interactive009/interactive009.idr+27
This diff is too big to show here.
test/interactive009/run.sh+3
This diff is too big to show here.
test/interactive010/expected.out+24
This diff is too big to show here.
test/interactive010/input.in+9
This diff is too big to show here.
test/interactive010/run.sh+2
This diff is too big to show here.
test/interactive011/.gitignore+1
This diff is too big to show here.
test/interactive011/expected.out+3
This diff is too big to show here.
test/interactive011/input.in+2
This diff is too big to show here.
test/interactive011/interactive011.ipkg+8
This diff is too big to show here.
test/interactive011/run.sh+6
This diff is too big to show here.
test/interactive011/src/Foo.idr+5
This diff is too big to show here.
test/interactive011/src/Main.idr+14
This diff is too big to show here.
test/interactive012/expected.out+33
This diff is too big to show here.
test/interactive012/input.in+9
This diff is too big to show here.
test/interactive012/interactive012.idr+26
This diff is too big to show here.
test/interactive012/run.sh+3
This diff is too big to show here.
test/interactive013/expected.out+4
This diff is too big to show here.
test/interactive013/input.in+1
This diff is too big to show here.
test/interactive013/interactive013.idr+4
This diff is too big to show here.
test/interactive013/run.sh+3
This diff is too big to show here.
test/interactive014/expected.out+7
This diff is too big to show here.
test/interactive014/input.in+5
This diff is too big to show here.
test/interactive014/interactive014.idr+10
This diff is too big to show here.
test/interactive014/run.sh+3
This diff is too big to show here.
test/interactive015/expected.out+6
This diff is too big to show here.
test/interactive015/input.in+2
This diff is too big to show here.
test/interactive015/run.sh+8
This diff is too big to show here.
test/interactive015/src/interactive015.idr+4
This diff is too big to show here.
test/interactive016/expected.out+7
This diff is too big to show here.
test/interactive016/input.in+2
This diff is too big to show here.
test/interactive016/run.sh+8
This diff is too big to show here.
test/interactive016/src/interactive016.idr+7
This diff is too big to show here.
test/interactive017/TestMod.idr+5
This diff is too big to show here.
test/interactive017/expected.out+7
This diff is too big to show here.
test/interactive017/run.sh+9
This diff is too big to show here.
test/interactive017/shebang-args.idr+6
This diff is too big to show here.
test/interactive017/shebang-import.idr+6
This diff is too big to show here.
test/interactive017/shebang-node.idr+4
This diff is too big to show here.
test/interactive017/shebang.idr+4
This diff is too big to show here.
test/interactive018/Imported1.idr+10
This diff is too big to show here.
test/interactive018/Imported2.idr+8
This diff is too big to show here.
test/interactive018/Public1.idr+10
This diff is too big to show here.
test/interactive018/Public2.idr+8
This diff is too big to show here.
test/interactive018/Top.idr+11
This diff is too big to show here.
test/interactive018/expected.out+20
This diff is too big to show here.
test/interactive018/input.in+20
This diff is too big to show here.
test/interactive018/run.sh+3
This diff is too big to show here.
test/interfaces001/InterfaceName.idr+8−8
This diff is too big to show here.
test/interfaces001/expected.out+6−3
This diff is too big to show here.
test/interfaces001/input.in
This diff is too big to show here.
test/interfaces001/run.sh+3
This diff is too big to show here.
test/interfaces002/expected.out+1
This diff is too big to show here.
test/interfaces002/interfaces002.idr+38
This diff is too big to show here.
test/interfaces002/run.sh+4
This diff is too big to show here.
test/interfaces003/expected.out+2
This diff is too big to show here.
test/interfaces003/interfaces003.idr+22
This diff is too big to show here.
test/interfaces003/run.sh+4
This diff is too big to show here.
test/interfaces004/expected.out+4
This diff is too big to show here.
test/interfaces004/interfaces004.idr+35
This diff is too big to show here.
test/interfaces004/run.sh+4
This diff is too big to show here.
test/interfaces005/expected.out+7
This diff is too big to show here.
test/interfaces005/interfaces005.idr+53
This diff is too big to show here.
test/interfaces005/interfaces005a.idr+50
This diff is too big to show here.
test/interfaces005/interfaces005b.idr+50
This diff is too big to show here.
test/interfaces005/run.sh+5
This diff is too big to show here.
test/interfaces006/expected.out
This diff is too big to show here.
test/interfaces006/interfaces006.idr+19
This diff is too big to show here.
test/interfaces006/run.sh+3
This diff is too big to show here.
test/interfaces007/expected.out+1
This diff is too big to show here.
test/interfaces007/interfaces007.idr+52
This diff is too big to show here.
test/interfaces007/run.sh+4
This diff is too big to show here.
test/interfaces008/expected.out+6
This diff is too big to show here.
test/interfaces008/interfaces008.idr+20
This diff is too big to show here.
test/interfaces008/run.sh+3
This diff is too big to show here.
test/interfaces009/expected.out
This diff is too big to show here.
test/interfaces009/interfaces009.idr+24
This diff is too big to show here.
test/interfaces009/run.sh+3
This diff is too big to show here.
test/interfaces010/expected.out
This diff is too big to show here.
test/interfaces010/interfaces010.idr+12
This diff is too big to show here.
test/interfaces010/run.sh+3
This diff is too big to show here.
test/interpret001/double-echo.idr+6
This diff is too big to show here.
test/interpret001/expected.out+2
This diff is too big to show here.
test/interpret001/input.in+2
This diff is too big to show here.
test/interpret001/run.sh+3
This diff is too big to show here.
test/interpret002/expected.out+4
This diff is too big to show here.
test/interpret002/file-error.idr+6
This diff is too big to show here.
test/interpret002/input.in+2
This diff is too big to show here.
test/interpret002/readable.txt+1
This diff is too big to show here.
test/interpret002/run.sh+3
This diff is too big to show here.
test/interpret003/expected.out+1
This diff is too big to show here.
test/interpret003/input.in+1
This diff is too big to show here.
test/interpret003/interpret003.idr+4
This diff is too big to show here.
test/interpret003/run.sh+3
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.
test/io001/test004.idr+8−8
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/io002/test008.idr+1−1
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.
test/io003/test018.idr+5−2
This diff is too big to show here.
test/io003/test018a.idr+4−2
This diff is too big to show here.
test/layout001/expected.out+82
This diff is too big to show here.
test/layout001/layout001a.idr+5
This diff is too big to show here.
test/layout001/layout001b.idr+5
This diff is too big to show here.
test/layout001/layout001c.idr+3
This diff is too big to show here.
test/layout001/layout001d.idr+3
This diff is too big to show here.
test/layout001/layout001e.idr+6
This diff is too big to show here.
test/layout001/layout001f.idr+6
This diff is too big to show here.
test/layout001/layout001g.idr+6
This diff is too big to show here.
test/layout001/layout001h.idr+6
This diff is too big to show here.
test/layout001/layout001i.idr+6
This diff is too big to show here.
test/layout001/layout001j.idr+6
This diff is too big to show here.
test/layout001/layout001k.idr+6
This diff is too big to show here.
test/layout001/layout001l.idr+6
This diff is too big to show here.
test/layout001/layout001n.idr+33
This diff is too big to show here.
test/layout001/mplus1.idr+17
This diff is too big to show here.
test/layout001/mplus2.idr+17
This diff is too big to show here.
test/layout001/mplus3.idr+17
This diff is too big to show here.
This diff is too big to show here.
test/literate001/Lit.lidr+2−2
This diff is too big to show here.
test/literate001/expected−7
This diff is too big to show here.
test/literate001/expected.out+12
This diff is too big to show here.
This diff is too big to show here.
test/literate001/run.sh+5
This diff is too big to show here.
test/meta001/Finite.idr+49−45
This diff is too big to show here.
test/meta001/expected.out
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/meta002/AgdaStyleReflection.idr+320
This diff is too big to show here.
test/meta002/DataDef.idr+75
This diff is too big to show here.
test/meta002/Deriving.idr+35
This diff is too big to show here.
test/meta002/Tacs.idr+69−17
This diff is too big to show here.
This diff is too big to show here.
test/meta002/expected.out+25
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/meta003/BadDef.idr+14
This diff is too big to show here.
test/meta003/Catch.idr+17
This diff is too big to show here.
test/meta003/expected.out+12
This diff is too big to show here.
This diff is too big to show here.
test/meta004/expected.out+7
This diff is too big to show here.
test/meta004/meta004.idr+50
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.
test/pkg001/expected.out+23
This diff is too big to show here.
This diff is too big to show here.
test/pkg001/test-pkg.ipkg+17
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.
test/pkg004/expected.out+6
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/pkg005/expected.out+1
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/pkg006/expected.out+1
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/pkg007/expected.out+1
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/pkg007/toy/Toy.idr+4
This diff is too big to show here.
test/pkg007/toy/Toy/Vehicle.idr+4
This diff is too big to show here.
test/pkg007/toy/Toy/Vehicle/Car.idr+3
This diff is too big to show here.
test/pkg007/toy/toy.ipkg+7
This diff is too big to show here.
test/pkg008/expected.out+13
This diff is too big to show here.
test/pkg008/maths.ipkg+10
This diff is too big to show here.
This diff is too big to show here.
test/pkg008/src/NumOps.idr+9
This diff is too big to show here.
test/pkg008/src/Test.idr+21
This diff is too big to show here.
test/pkg009/datatype.ipkg+6
This diff is too big to show here.
test/pkg009/expected.out+9
This diff is too big to show here.
This diff is too big to show here.
test/pkg009/src/Data/Type.idr+3
This diff is too big to show here.
test/pkg010/expected.out+29
This diff is too big to show here.
This diff is too big to show here.
test/pkg010/wrongopts.ipkg+3
This diff is too big to show here.
test/prelude001/expected.out+10
This diff is too big to show here.
test/prelude001/prelude001.idr+14
This diff is too big to show here.
This diff is too big to show here.
test/primitives001/expected−6
This diff is too big to show here.
test/primitives001/expected.out+27
This diff is too big to show here.
test/primitives001/input.in+2
This diff is too big to show here.
This diff is too big to show here.
test/primitives001/run.sh+6
This diff is too big to show here.
test/primitives001/substring.idr+58
This diff is too big to show here.
test/primitives001/test005.idr−1
This diff is too big to show here.
test/primitives002/expected.out+13−13
This diff is too big to show here.
test/primitives002/run−52
This diff is too big to show here.
test/primitives002/run.sh+54
This diff is too big to show here.
test/primitives003/expected.out+4
This diff is too big to show here.
This diff is too big to show here.
test/primitives003/run.sh+5
This diff is too big to show here.
test/primitives003/test038.idr+14−10
This diff is too big to show here.
test/primitives004-disabled/expected.out
This diff is too big to show here.
test/primitives004-disabled/run−4
This diff is too big to show here.
test/primitives004-disabled/run.sh+4
This diff is too big to show here.
test/primitives005/expected.out+2
This diff is too big to show here.
test/primitives005/primitives005.idr+24
This diff is too big to show here.
test/primitives005/run.sh+5
This diff is too big to show here.
test/primitives006/Data/ByteArray.idr+100
This diff is too big to show here.
test/primitives006/Data/Bytes.idr+286
This diff is too big to show here.
test/primitives006/array.c+62
This diff is too big to show here.
test/primitives006/array.h+18
This diff is too big to show here.
test/primitives006/expected.out+9
This diff is too big to show here.
test/primitives006/load-test.idr+48
This diff is too big to show here.
test/primitives006/run.sh+6
This diff is too big to show here.
test/proof001/expected.out+12
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/proof001/test029.idr+4−5
This diff is too big to show here.
test/proof002/Reflect.idr+51−51
This diff is too big to show here.
test/proof002/expected−13
This diff is too big to show here.
test/proof002/expected.out+37
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/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.
This diff is too big to show here.
test/proof003/expected.out+39
This diff is too big to show here.
This diff is too big to show here.
test/proof003/test015.idr+36−32
This diff is too big to show here.
test/proof004/expected.out
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/proof005/DefaultArgSubstitutionSuccess.idr+4−4
This diff is too big to show here.
test/proof005/expected.out
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/proof006/DefaultArgSubstitutionSyntax.idr+4−4
This diff is too big to show here.
test/proof006/expected.out
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.
test/proof007/expected.out+10
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/proof008/expected.out+6
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/proof009/expected.out+6−5
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.
test/proof010/expected.out
This diff is too big to show here.
test/proof010/proof010.idr+6−6
This diff is too big to show here.
This diff is too big to show here.
test/proof011/expected.out+28
This diff is too big to show here.
test/proof011/proof011.idr+21
This diff is too big to show here.
test/proof011/proof011a.idr+14
This diff is too big to show here.
This diff is too big to show here.
test/proofsearch001/expected.out
This diff is too big to show here.
test/proofsearch001/proofsearch001.idr+11
This diff is too big to show here.
test/proofsearch001/run.sh+3
This diff is too big to show here.
test/proofsearch002/Process.idr+444
This diff is too big to show here.
test/proofsearch002/expected.out
This diff is too big to show here.
test/proofsearch002/proofsearch002.idr+48
This diff is too big to show here.
test/proofsearch002/run.sh+3
This diff is too big to show here.
test/proofsearch003/expected.out
This diff is too big to show here.
test/proofsearch003/proofsearch003.idr+34
This diff is too big to show here.
test/proofsearch003/run.sh+3
This diff is too big to show here.
test/pruviloj001/expected.out
This diff is too big to show here.
test/pruviloj001/pruviloj001.idr+84
This diff is too big to show here.
test/pruviloj001/run.sh+3
This diff is too big to show here.
test/quasiquote001/QuasiquoteBasics.idr−3
This diff is too big to show here.
test/quasiquote001/expected−5
This diff is too big to show here.
test/quasiquote001/expected.out+5
This diff is too big to show here.
test/quasiquote001/run.sh+1−1
This diff is too big to show here.
test/quasiquote002/expected.out
This diff is too big to show here.
test/quasiquote002/run.sh+1−1
This diff is too big to show here.
test/quasiquote003/expected−2
This diff is too big to show here.
test/quasiquote003/expected.out+9
This diff is too big to show here.
This diff is too big to show here.
test/quasiquote003/run.sh+3
This diff is too big to show here.
test/quasiquote004/expected−3
This diff is too big to show here.
test/quasiquote004/expected.out+27
This diff is too big to show here.
This diff is too big to show here.
test/quasiquote004/run.sh+3
This diff is too big to show here.
test/quasiquote005/expected.out
This diff is too big to show here.
This diff is too big to show here.
test/quasiquote005/run.sh+3
This diff is too big to show here.
test/quasiquote006/expected−13
This diff is too big to show here.
test/quasiquote006/expected.out+31
This diff is too big to show here.
test/quasiquote006/quasiquote006.idr+2−2
This diff is too big to show here.
This diff is too big to show here.
test/quasiquote006/run.sh+3
This diff is too big to show here.
test/records001/expected.out
This diff is too big to show here.
test/records001/run.sh+1−1
This diff is too big to show here.
test/records002/expected.out
This diff is too big to show here.
test/records002/record002.idr+1−1
This diff is too big to show here.
test/records002/run.sh+1−1
This diff is too big to show here.
test/records003/expected.out
This diff is too big to show here.
test/records003/run.sh+1−1
This diff is too big to show here.
test/records004/expected.out+3
This diff is too big to show here.
test/records004/records004.idr+13
This diff is too big to show here.
This diff is too big to show here.
test/records005/expected.out+4
This diff is too big to show here.
test/records005/records005.idr+39
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/reg001/TestEx.idr+31
This diff is too big to show here.
test/reg001/expected.out+3
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.
test/reg005/expected.out+3
This diff is too big to show here.
test/reg005/reg005.idr+6−9
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.
test/reg007/expected.out+14
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/reg009/reg009.lidr−21
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.
test/reg011/reg011.idr−11
This diff is too big to show here.
This diff is too big to show here.
test/reg012/reg012.lidr−36
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.
test/reg014/reg014.idr−14
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.
test/reg017/expected.out+13
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.
test/reg021/reg021.idr−22
This diff is too big to show here.
This diff is too big to show here.
test/reg022/reg022.idr−18
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.
test/reg026/reg026.idr−16
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/reg027/expected.out+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.
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.
test/reg030/reg030.idr−15
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.
test/reg033/reg033.idr−12
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.
test/reg040/reg040.idr+1−1
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.
test/reg041/expected.out+2
This diff is too big to show here.
test/reg041/ott.idr+24−25
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.
test/reg045/reg045.idr+1−1
This diff is too big to show here.
This diff is too big to show here.
test/reg046/reg046.idr−19
This diff is too big to show here.
This diff is too big to show here.
test/reg047/reg047.idr−18
This diff is too big to show here.
test/reg047/reg047a.idr−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.
This diff is too big to show here.
test/reg048/reg048.idr+1−1
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.
test/reg051-disabled/expected
This diff is too big to show here.
test/reg051-disabled/expected.out
This diff is too big to show here.
test/reg051-disabled/run−3
This diff is too big to show here.
test/reg051-disabled/run.sh+3
This diff is too big to show here.
This diff is too big to show here.
test/reg052/reg052.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.
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.
test/reg060/reg060.idr−12
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.
test/reg062/reg062.lidr−41
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.
test/reg067/expected.out+1
This diff is too big to show here.
test/reg067/reg067.idr+23
This diff is too big to show here.
This diff is too big to show here.
test/reg075/expected.out+6
This diff is too big to show here.
This diff is too big to show here.
test/reg075/reg075.idr+33
This diff is too big to show here.
This diff is too big to show here.
test/reg076/expected.out+1
This diff is too big to show here.
This diff is too big to show here.
test/reg076/reg076.idr+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/reg077/reg077.idr+17
This diff is too big to show here.
This diff is too big to show here.
test/regression001/coverage001.idr+79
This diff is too big to show here.
test/regression001/eff001.idr+39
This diff is too big to show here.
test/regression001/expected.out
This diff is too big to show here.
test/regression001/reg001.idr+209
This diff is too big to show here.
test/regression001/reg002.idr+8
This diff is too big to show here.
test/regression001/reg003.idr+11
This diff is too big to show here.
test/regression001/reg004.lidr+43
This diff is too big to show here.
test/regression001/reg005.idr+8
This diff is too big to show here.
test/regression001/reg006.idr+14
This diff is too big to show here.
test/regression001/reg007.idr+69
This diff is too big to show here.
test/regression001/reg036.idr+2−2
This diff is too big to show here.
test/regression001/reg037.idr+2−2
This diff is too big to show here.
test/regression001/reg038.idr+4−4
This diff is too big to show here.
test/regression001/reg046.idr+19
This diff is too big to show here.
test/regression001/reg047.idr+18
This diff is too big to show here.
test/regression001/reg047a.idr+24
This diff is too big to show here.
test/regression001/reg053.idr
This diff is too big to show here.
test/regression001/reg057.idr
This diff is too big to show here.
test/regression001/reg058.idr+2−2
This diff is too big to show here.
test/regression001/reg058a.idr
This diff is too big to show here.
test/regression001/reg059.idr+2−2
This diff is too big to show here.
test/regression001/reg060.idr+12
This diff is too big to show here.
test/regression001/reg061.idr
This diff is too big to show here.
test/regression001/reg062.idr
This diff is too big to show here.
test/regression001/reg063.idr
This diff is too big to show here.
test/regression001/reg064.idr+8
This diff is too big to show here.
test/regression001/reg065.idr+26
This diff is too big to show here.
test/regression001/reg066.idr+7
This diff is too big to show here.
test/regression001/reg071.idr+19
This diff is too big to show here.
test/regression001/reg073.lidr+24
This diff is too big to show here.
test/regression001/reg074.idr+21
This diff is too big to show here.
test/regression001/run.sh+18
This diff is too big to show here.
test/regression002/A.lidr+1−1
This diff is too big to show here.
test/regression002/Canonicity.idr+13
This diff is too big to show here.
test/regression002/DoubleEquality.idr+5
This diff is too big to show here.
test/regression002/Mod.idr+12
This diff is too big to show here.
test/regression002/Negation.idr+2
This diff is too big to show here.
test/regression002/badbangop.idr
This diff is too big to show here.
test/regression002/baddoublebang.idr
This diff is too big to show here.
test/regression002/expected.out+368
This diff is too big to show here.
test/regression002/reg001.idr+2
This diff is too big to show here.
test/regression002/reg002.idr+3
This diff is too big to show here.
test/regression002/reg003.idr
This diff is too big to show here.
test/regression002/reg003a.idr
This diff is too big to show here.
test/regression002/reg006.idr+3−2
This diff is too big to show here.
test/regression002/reg007.lidr
This diff is too big to show here.
test/regression002/reg010.idr
This diff is too big to show here.
test/regression002/reg018a.idr
This diff is too big to show here.
test/regression002/reg018b.idr+1−1
This diff is too big to show here.
test/regression002/reg018c.idr
This diff is too big to show here.
test/regression002/reg018d.idr
This diff is too big to show here.
test/regression002/reg023.idr
This diff is too big to show here.
test/regression002/reg028.idr
This diff is too big to show here.
test/regression002/reg028a.idr
This diff is too big to show here.
test/regression002/reg034.idr
This diff is too big to show here.
test/regression002/reg035.idr
This diff is too big to show here.
test/regression002/reg035a.lidr+7−8
This diff is too big to show here.
test/regression002/reg035b.idr
This diff is too big to show here.
test/regression002/reg044.idr
This diff is too big to show here.
test/regression002/reg049.idr
This diff is too big to show here.
test/regression002/reg054.idr+3
This diff is too big to show here.
test/regression002/reg055.idr
This diff is too big to show here.
test/regression002/reg055a.idr
This diff is too big to show here.
test/regression002/reg056.idr+1−2
This diff is too big to show here.
test/regression002/reg068.idr+4
This diff is too big to show here.
test/regression002/reg069.idr+5
This diff is too big to show here.
test/regression002/reg070.idr+15
This diff is too big to show here.
test/regression002/reg076.idr+7
This diff is too big to show here.
test/regression002/reg077.idr+2
This diff is too big to show here.
test/regression002/run.sh+41
This diff is too big to show here.
test/regression002/working.idr
This diff is too big to show here.
test/regression003/expected.out+1
This diff is too big to show here.
test/regression003/regression003.idr+56
This diff is too big to show here.
test/regression003/run.sh+4
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/sourceLocation001/SourceLoc.idr+1
This diff is too big to show here.
test/sourceLocation001/expected−11
This diff is too big to show here.
test/sourceLocation001/expected.out+35
This diff is too big to show here.
test/sourceLocation001/run.sh+1−1
This diff is too big to show here.
test/st001/expected.out+8
This diff is too big to show here.
This diff is too big to show here.
test/st001/test001.idr+66
This diff is too big to show here.
This diff is too big to show here.
test/st002/expected.out+8
This diff is too big to show here.
This diff is too big to show here.
test/st002/test002.idr+66
This diff is too big to show here.
This diff is too big to show here.
test/st003/expected.out+8
This diff is too big to show here.
This diff is too big to show here.
test/st003/test003.idr+25
This diff is too big to show here.
This diff is too big to show here.
test/st004/expected.out+6
This diff is too big to show here.
This diff is too big to show here.
test/st004/test004.idr+24
This diff is too big to show here.
test/st005/expected.out+6
This diff is too big to show here.
This diff is too big to show here.
test/st005/test005.idr+33
This diff is too big to show here.
test/st006/expected.out+5
This diff is too big to show here.
This diff is too big to show here.
test/st006/test006.idr+37
This diff is too big to show here.
test/st007/expected.out+6
This diff is too big to show here.
This diff is too big to show here.
test/st007/test007.idr+24
This diff is too big to show here.
test/sugar001/expected.out
This diff is too big to show here.
This diff is too big to show here.
test/sugar001/test007.idr+2−2
This diff is too big to show here.
test/sugar002/expected.out
This diff is too big to show here.
This diff is too big to show here.
test/sugar003/expected.out
This diff is too big to show here.
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.out+1
This diff is too big to show here.
This diff is too big to show here.
test/sugar004/sugar004.idr+12−1
This diff is too big to show here.
This diff is too big to show here.
test/sugar005/expected.out
This diff is too big to show here.
This diff is too big to show here.
test/syntax001/Syntax.idr+8
This diff is too big to show here.
test/syntax001/SyntaxOk.idr+6
This diff is too big to show here.
test/syntax001/SyntaxTest.idr+5
This diff is too big to show here.
test/syntax001/expected.out+26
This diff is too big to show here.
This diff is too big to show here.
test/syntax002/expected.out+2
This diff is too big to show here.
This diff is too big to show here.
test/syntax002/syntax002.idr+22
This diff is too big to show here.
test/tactics001/Tactics.idr+8−6
This diff is too big to show here.
This diff is too big to show here.
test/tactics001/expected.out
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/totality001/expected−6
This diff is too big to show here.
test/totality001/expected.out+18
This diff is too big to show here.
This diff is too big to show here.
test/totality001/run.sh+6
This diff is too big to show here.
test/totality002/expected−4
This diff is too big to show here.
test/totality002/expected.out+18
This diff is too big to show here.
This diff is too big to show here.
test/totality002/run.sh+5
This diff is too big to show here.
test/totality002/test017.idr+6−6
This diff is too big to show here.
test/totality003/expected.out+5−1
This diff is too big to show here.
This diff is too big to show here.
test/totality003/run.sh+4
This diff is too big to show here.
test/totality004/expected−5
This diff is too big to show here.
test/totality004/expected.out+13
This diff is too big to show here.
This diff is too big to show here.
test/totality004/run.sh+5
This diff is too big to show here.
test/totality004/totality004.idr+7−7
This diff is too big to show here.
test/totality004/totality004a.idr+7−8
This diff is too big to show here.
test/totality005/expected.out
This diff is too big to show here.
This diff is too big to show here.
test/totality005/run.sh+5
This diff is too big to show here.
test/totality006/expected−5
This diff is too big to show here.
test/totality006/expected.out+18
This diff is too big to show here.
This diff is too big to show here.
test/totality006/run.sh+5
This diff is too big to show here.
test/totality007/expected.msys+2
This diff is too big to show here.
test/totality007/expected.out+9
This diff is too big to show here.
This diff is too big to show here.
test/totality007/run.sh+3
This diff is too big to show here.
test/totality008/expected−2
This diff is too big to show here.
test/totality008/expected.out+6
This diff is too big to show here.
This diff is too big to show here.
test/totality008/run.sh+3
This diff is too big to show here.
test/totality008/totality008.idr+4−4
This diff is too big to show here.
test/totality009/TestLambdaPossible.idr+1
This diff is too big to show here.
test/totality009/TestLambdaPossible2.idr+16
This diff is too big to show here.
test/totality009/expected−8
This diff is too big to show here.
test/totality009/expected.out+60
This diff is too big to show here.
This diff is too big to show here.
test/totality009/run.sh+6
This diff is too big to show here.
test/totality010/expected.out+12
This diff is too big to show here.
test/totality010/run.sh+3
This diff is too big to show here.
test/totality010/totality010.idr+31
This diff is too big to show here.
test/totality011/expected.out+6
This diff is too big to show here.
test/totality011/run.sh+3
This diff is too big to show here.
test/totality011/totality011.lidr+31
This diff is too big to show here.
test/totality012/expected.out+12
This diff is too big to show here.
test/totality012/run.sh+5
This diff is too big to show here.
test/totality012/totality012.idr+30
This diff is too big to show here.
test/totality012/totality012a.idr+12
This diff is too big to show here.
test/totality012/totality012b.idr+18
This diff is too big to show here.
test/totality013/expected.out+12
This diff is too big to show here.
test/totality013/run.sh+4
This diff is too big to show here.
test/totality013/totality013.idr+16
This diff is too big to show here.
test/totality013/totality013a.idr+17
This diff is too big to show here.
test/totality014/expected.out+13
This diff is too big to show here.
test/totality014/run.sh+3
This diff is too big to show here.
test/totality014/totality014.idr+7
This diff is too big to show here.
test/totality015/expected.out+18
This diff is too big to show here.
test/totality015/run.sh+4
This diff is too big to show here.
test/totality015/totality015.idr+70
This diff is too big to show here.
test/totality015/totality015a.idr+63
This diff is too big to show here.
test/totality016/expected.out+54
This diff is too big to show here.
test/totality016/run.sh+3
This diff is too big to show here.
test/totality016/totality016.idr+48
This diff is too big to show here.
test/totality017/expected.out+36
This diff is too big to show here.
test/totality017/run.sh+3
This diff is too big to show here.
test/totality017/totality017.idr+49
This diff is too big to show here.
test/totality018/expected.out+6
This diff is too big to show here.
test/totality018/run.sh+3
This diff is too big to show here.
test/totality018/totality018.idr+15
This diff is too big to show here.
test/totality019/expected.out+12
This diff is too big to show here.
test/totality019/run.sh+4
This diff is too big to show here.
test/totality019/totality019.idr+14
This diff is too big to show here.
test/totality019/totality019a.idr+81
This diff is too big to show here.
test/totality020/expected.out+12
This diff is too big to show here.
test/totality020/run.sh+3
This diff is too big to show here.
test/totality020/totality020.idr+11
This diff is too big to show here.
test/totality021/expected.out+30
This diff is too big to show here.
test/totality021/run.sh+4
This diff is too big to show here.
test/totality021/totality021.idr+18
This diff is too big to show here.
test/totality021/totality021a.idr+12
This diff is too big to show here.
test/totality022/expected.out+6
This diff is too big to show here.
test/totality022/run.sh+3
This diff is too big to show here.
test/totality022/totality022.idr+11
This diff is too big to show here.
test/totality023/expected.out+6
This diff is too big to show here.
test/totality023/run.sh+3
This diff is too big to show here.
test/totality023/totality023.idr+11
This diff is too big to show here.
test/totality024/expected.out+1
This diff is too big to show here.
test/totality024/run.sh+3
This diff is too big to show here.
test/totality024/totality023.idr+7
This diff is too big to show here.
test/totality025/expected.out+18
This diff is too big to show here.
test/totality025/run.sh+3
This diff is too big to show here.
test/totality025/totality025.idr+17
This diff is too big to show here.
test/totality026/expected.out+6
This diff is too big to show here.
test/totality026/run.sh+3
This diff is too big to show here.
test/totality026/totality026.idr+7
This diff is too big to show here.
test/tutorial001/expected
This diff is too big to show here.
test/tutorial001/expected.out
This diff is too big to show here.
This diff is too big to show here.
test/tutorial001/run.sh+3
This diff is too big to show here.
test/tutorial002/expected
This diff is too big to show here.
test/tutorial002/expected.out+18
This diff is too big to show here.
This diff is too big to show here.
test/tutorial002/run.sh+3
This diff is too big to show here.
test/tutorial002/tutorial002.idr+16−16
This diff is too big to show here.
test/tutorial003/expected
This diff is too big to show here.
test/tutorial003/expected.out
This diff is too big to show here.
This diff is too big to show here.
test/tutorial003/run.sh+3
This diff is too big to show here.
test/tutorial003/tutorial003.idr+2−2
This diff is too big to show here.
test/tutorial004/expected
This diff is too big to show here.
test/tutorial004/expected.out+12
This diff is too big to show here.
This diff is too big to show here.
test/tutorial004/run.sh+3
This diff is too big to show here.
test/tutorial005/expected
This diff is too big to show here.
test/tutorial005/expected.out
This diff is too big to show here.
This diff is too big to show here.
test/tutorial005/run.sh+3
This diff is too big to show here.
test/tutorial006/expected−25
This diff is too big to show here.
test/tutorial006/expected.out+37
This diff is too big to show here.
This diff is too big to show here.
test/tutorial006/run.sh+5
This diff is too big to show here.
test/tutorial006/tutorial006b.idr+6−6
This diff is too big to show here.
test/tutorial006/tutorial006c.idr+20
This diff is too big to show here.
test/tutorial007/Providers.idr+27
This diff is too big to show here.
test/tutorial007/expected.out+1
This diff is too big to show here.
test/tutorial007/nativetypes.c+13
This diff is too big to show here.
test/tutorial007/run.sh+5
This diff is too big to show here.
test/tutorial007/tutorial007.idr+12
This diff is too big to show here.
test/unique001/expected−21
This diff is too big to show here.
test/unique001/expected.out+4
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/unique001/unique001.idr+2
This diff is too big to show here.
test/unique002/expected−5
This diff is too big to show here.
This diff is too big to show here.
test/unique003/expected−4
This diff is too big to show here.
This diff is too big to show here.
test/unique004/expected.out+75
This diff is too big to show here.
This diff is too big to show here.
test/unique004/unique001a.idr+2
This diff is too big to show here.
test/unique004/unique001b.idr+2
This diff is too big to show here.
test/unique004/unique001c.idr+4−7
This diff is too big to show here.
test/unique004/unique001d.idr+1
This diff is too big to show here.
test/unique004/unique001e.idr+1
This diff is too big to show here.
test/unique004/unique002.idr+3−1
This diff is too big to show here.
test/unique004/unique002a.idr+3−1
This diff is too big to show here.
test/unique004/unique003.idr+3−1
This diff is too big to show here.
test/universes001/expected.out+14
This diff is too big to show here.
test/universes001/run.sh+3
This diff is too big to show here.
test/universes001/universes001.idr+8
This diff is too big to show here.
test/universes002/expected.out+14
This diff is too big to show here.
test/universes002/run.sh+3
This diff is too big to show here.
test/universes002/universes002.idr+45
This diff is too big to show here.
test/views001/expected.out+5
This diff is too big to show here.
This diff is too big to show here.
test/views001/views001.idr+43
This diff is too big to show here.
test/views001/views001a.idr+29
This diff is too big to show here.
test/views002/expected.out+2
This diff is too big to show here.
This diff is too big to show here.
test/views002/views002.idr+26
This diff is too big to show here.
test/views003/expected.out+1
This diff is too big to show here.
This diff is too big to show here.
test/views003/views003.idr+31
This diff is too big to show here.