git.iko.soy/Idris-dev

on master help sign in

from

swap

toc6c928f7402 ahead, 0 behind

compare

.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.

3+

4+# Steps to Reproduce

5+

6+# Expected Behavior

7+

8+# Observed Behavior

9+

.gitignore+45−15

@@ -1,25 +1,55 @@

1+# Build artefacts

12dist

2−cabal-dev/

3+dist-newstyle

34*.ibc

45*.o

56*.a

67*.so

78*.dll

89*.dylib

10+src/Version_idris.hs

11+

12+# Doc generation artefacts

13+libs/base/base_doc/

14+libs/effects/effects_doc/

15+libs/prelude/prelude_doc/

16+libs/contrib/contrib_doc/

17+libs/pruviloj/pruviloj_doc/

18+libs/oldeffects/oldeffects_doc/

19+

20+# Test artefacts

21+test/output

22+test/*[0-9][0-9][0-9]/output

23+test/*[0-9][0-9][0-9]/*.exe

24+test/runtest.exe

25+test/runtest

26+.tasty-rerun-log

27+

28+# Haskell build tools

29+cabal-dev/

30+.cabal-sandbox

31+cabal.sandbox.config

32+cabal.config

33+.stack-work

34+.hsenv

35+

36+# For convenience

37+custom.mk

38+\#*

39+.\#*

40+tags

41+TAGS

42+

43+# IDE and editors

944*.swp

1045*~

1146.DS_Store

12−custom.mk

13−test/output

14−test/test???/output

15−test/reg???/output

16−test/test???/*.exe

17−test/reg???/*.exe

18−tutorial/*.aux

19−tutorial/*.bbl

20−tutorial/*.blg

21−tutorial/*.log

22−tutorial/*.out

23−tutorial/*.toc

24−tutorial/*.fdb_latexmk

25−tutorial/*.fls

47+.hpc

48+*.orig

49+*.tix

50+*.dSYM

51+.projectile

52+.dir-locals.el

53+.vscode

54+.idea

55+

.hlint.yamlnew file+61

@@ -0,0 +1,61 @@

1+# HLint configuration file

2+# https://github.com/ndmitchell/hlint

3+##########################

4+

5+# This file contains a template configuration file, which is typically

6+# placed as .hlint.yaml in the root of your project

7+

8+

9+# Specify additional command line arguments

10+#

11+# - arguments: [--color, --cpp-simple, -XQuasiQuotes]

12+

13+

14+# Control which extensions/flags/modules/functions can be used

15+#

16+# - extensions:

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

20+#

21+# - flags:

22+# - {name: -w, within: []} # -w is allowed nowhere

23+#

24+# - modules:

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

27+#

28+# - functions:

29+# - {name: unsafePerformIO, within: []} # unsafePerformIO can only appear in no modules

30+

31+

32+# Add custom hints for this project

33+#

34+# Will suggest replacing "wibbleMany [myvar]" with "wibbleOne myvar"

35+# - error: {lhs: "wibbleMany [x]", rhs: wibbleOne x}

36+

37+

38+# Turn on hints that are off by default

39+#

40+# Ban "module X(module X) where", to require a real export list

41+# - warn: {name: Use explicit module export list}

42+#

43+# Replace a $ b $ c with a . b $ c

44+# - group: {name: dollar, enabled: true}

45+#

46+# Generalise map to fmap, ++ to <>

47+# - group: {name: generalise, enabled: true}

48+

49+

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}

55+

56+# Define some custom infix operators

57+# - fixity: infixr 3 ~^#^~

58+

59+

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+# ==================================

3+

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.

7+steps:

8+ # Convert some ASCII sequences to their Unicode equivalents. This is disabled

9+ # by default.

10+ # - unicode_syntax:

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:

15+ # # true.

16+ # add_language_pragma: true

17+

18+ # Import cleanup

19+ - imports:

20+ # There are different ways we can align names and lists.

21+ #

22+ # - global: Align the import names and import list throughout the entire

23+ # file.

24+ #

25+ # - file: Like global, but don't add padding when there are no qualified

26+ # imports in the file.

27+ #

28+ # - group: Only align the imports per group (a group is formed by adjacent

29+ # import lines).

30+ #

31+ # - none: Do not perform any alignment.

32+ #

33+ # Default: global.

34+ align: none

35+

36+ # Folowing options affect only import list alignment.

37+ #

38+ # List align has following options:

39+ #

40+ # - after_alias: Import list is aligned with end of import including

41+ # 'as' and 'hiding' keywords.

42+ #

43+ # > import qualified Data.List as List (concat, foldl, foldr, head,

44+ # > init, last, length)

45+ #

46+ # - with_alias: Import list is aligned with start of alias or hiding.

47+ #

48+ # > import qualified Data.List as List (concat, foldl, foldr, head,

49+ # > init, last, length)

50+ #

51+ # - new_line: Import list starts always on new line.

52+ #

53+ # > import qualified Data.List as List

54+ # > (concat, foldl, foldr, head, init, last, length)

55+ #

56+ # Default: after_alias

57+ list_align: after_alias

58+

59+ # Long list align style takes effect when import is too long. This is

60+ # determined by 'columns' setting.

61+ #

62+ # - inline: This option will put as much specs on same line as possible.

63+ #

64+ # - new_line: Import list will start on new line.

65+ #

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.

68+ #

69+ # - multiline: One line per import list entry.

70+ # Type with contructor list acts like single import.

71+ #

72+ # > import qualified Data.Map as M

73+ # > ( empty

74+ # > , singleton

75+ # > , ...

76+ # > , delete

77+ # > )

78+ #

79+ # Default: inline

80+ long_list_align: inline

81+

82+ # List padding determines indentation of import list on lines after import.

83+ # This option affects 'list_align' and 'long_list_align'.

84+ list_padding: 4

85+

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.

89+ #

90+ # - true: There is single space between Foldable type and list of it's

91+ # functions.

92+ #

93+ # > import Data.Foldable (Foldable (fold, foldl, foldMap))

94+ #

95+ # - false: There is no space between Foldable type and list of it's

96+ # functions.

97+ #

98+ # > import Data.Foldable (Foldable(fold, foldl, foldMap))

99+ #

100+ # Default: true

101+ separate_lists: false

102+

103+ # Language pragmas

104+ - language_pragmas:

105+ # We can generate different styles of language pragma lists.

106+ #

107+ # - vertical: Vertical-spaced language pragmas, one per line.

108+ #

109+ # - compact: A more compact style.

110+ #

111+ # - compact_line: Similar to compact, but wrap each line with

112+ # `{-#LANGUAGE #-}'.

113+ #

114+ # Default: vertical.

115+ style: compact

116+

117+ # Align affects alignment of closing pragma brackets.

118+ #

119+ # - true: Brackets are aligned in same collumn.

120+ #

121+ # - false: Brackets are not aligned together. There is only one space

122+ # between actual import and closing bracket.

123+ #

124+ # Default: true

125+ align: true

126+

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

130+

131+ # Align the types in record declarations

132+ # - records: {}

133+

134+ # Replace tabs by spaces. This is disabled by default.

135+ - tabs:

136+ # # Number of spaces to use for each tab. Default: 8, as specified by the

137+ # # Haskell report.

138+ spaces: 8

139+

140+ # Remove trailing whitespace

141+ - trailing_whitespace: {}

142+

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.

145+columns: 80

146+

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.

150+#

151+# No language extensions are enabled by default.

152+# language_extensions:

153+ # - TemplateHaskell

154+ # - QuasiQuotes

.travis.yml+171−15

@@ -1,20 +1,176 @@

1−language: haskell

1+dist: xenial

2+

3+language: c

4+

5+env:

6+ global:

7+ - PKGNAME=idris

8+

9+matrix:

10+ include:

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]}}

42+ fast-finish: true

43+

44+cache:

45+ directories:

46+ - $HOME/.cabsnap

47+ - $HOME/.cabal/packages

48+ - $HOME/.stack

49+

50+before_cache:

51+ - rm -fv $HOME/.cabal/packages/hackage.haskell.org/build-reports.log

52+ - rm -fv $HOME/.cabal/packages/hackage.haskell.org/00-index.tar

53+

254before_install:

3− - sudo add-apt-repository --yes ppa:h-rayflood/llvm

4− - sudo apt-get update -qq

5− - sudo apt-get install -qq libgc-dev llvm-3.3

55+ - nvm install 6

56+ - nvm use 6

57+ - unset CC

58+ - if [[ $TRAVIS_OS_NAME == 'linux' ]];

59+ then

60+ export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$HOME/.cabal/bin:$HOME/opt/scheme/bin/:$PATH;

61+ export SED=sed;

62+ export ZCAT=zcat;

63+ fi

64+ - env

65+ - if [[ $TRAVIS_OS_NAME == 'osx' ]];

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;

70+ export SED=gsed;

71+ export ZCAT=gzcat;

72+ export PKG_CONFIG_PATH=/usr/local/opt/libffi/lib/pkgconfig:$PKG_CONFIG_PATH;

73+ fi

74+ - if [ -n "$STYLISH" ]; then ./stylize.sh; exit $?; fi

75+ - if [ -n "$IDRIS2" ];

76+ then

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 &&

82+ make -j install &&

83+ cd .. &&

84+ cabal v1-update &&

85+ travis_wait cabal v1-install &&

86+ cd Idris2 &&

87+ make idris2 && make base && make contrib;

88+ exit $?;

89+ fi

90+

691install:

7− - cabal install -f FFI -f LLVM --only-dependencies --enable-tests

92+ - which cabal

93+ - which ghc

94+ - cabal --version

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 ];

97+ then

98+ $ZCAT $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz >

99+ $HOME/.cabal/packages/hackage.haskell.org/00-index.tar;

100+ fi

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;

111+ then

112+ echo "cabal build-cache HIT";

113+ rm -rfv .ghc;

114+ cp -a $HOME/.cabsnap/ghc $HOME/.ghc;

115+ cp -a $HOME/.cabsnap/lib $HOME/.cabsnap/share $HOME/.cabsnap/bin $HOME/.cabal/;

116+ else

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;

121+ fi

122+ # snapshot package-db on cache miss

123+ - if [ ! -d $HOME/.cabsnap ];

124+ then

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/;

129+ fi

130+

131+

8132before_script:

9− - cabal sdist

133+ - ORIGINAL_DIR=$(pwd)

134+ - cabal v1-sdist

10135 - cd ..

11− - tar -xf Idris-dev/dist/idris*.tar.gz

12− - cd idris*

136+ - tar -xf ${ORIGINAL_DIR}/dist/${PKGNAME}*.tar.gz

137+ - cd ${PKGNAME}*

13138script:

14− - cabal configure -f FFI -f LLVM

15− - cabal build

16− - cabal copy

17− - make -j2 test

18− - make -j2 test_llvm

19− - make -j2 test_java

20−

139+ - export LD_PRELOAD=/opt/ghc/${GHCVER}/lib/ghc-${GHCVER}/rts/libffi.so.7

140+###

141+ - echo 'Configure...' && echo -en 'travis_fold:start:script.configure\\r'

142+ - cabal v1-configure -f FFI -f CI --enable-tests

143+ - echo -en 'travis_fold:end:script.configure\\r'

144+###

145+ - echo 'Build...' && echo -en 'travis_fold:start:script.build\\r'

146+ - cabal v1-build

147+ - echo -en 'travis_fold:end:script.build\\r'

148+###

149+ - echo 'Copy...' && echo -en 'travis_fold:start:script.copy\\r'

150+ - cabal v1-copy

151+ - echo -en 'travis_fold:end:script.copy\\r'

152+###

153+ - echo 'Register...' && echo -en 'travis_fold:start:script.register\\r'

154+ - cabal v1-register

155+ - echo -en 'travis_fold:end:script.register\\r'

156+###

157+ - echo 'Cppcheck...' && echo -en 'travis_fold:start:script.cppcheck\\r'

158+ - if [[ "$TESTS" == "test_c" ]]; then

159+ cppcheck -i 'mini-gmp.c' rts;

160+ fi

161+ - echo -en 'travis_fold:end:script.cppcheck\\r'

162+###

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;

167+ done

168+ - echo -en 'travis_fold:end:script.tests\\r'

169+###

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 ..;

173+ fi

174+ - echo -en 'travis_fold:end:script.benchmarks\\r'

175+###

176+# EOF

CHANGELOGdeleted−266

@@ -1,266 +0,0 @@

1−New in 0.9.10:

2−--------------

3−

4−* Type classes now implemented as dependent records, meaning that method

5− types may now depend on earlier methods.

6−* More flexible class instance resolution, so that function types and lambda

7− expressions can be made instances of a type class.

8−* Add '%reflection' option for functions, for compile-time operations on

9− syntax.

10−* Add 'quoteGoal x by p in e' which makes x equal to p applied to the goal

11− in the scope e

12−* Add !expr notation for implicit binding of intermediate results in

13− monadic/do/etc expressions

14−* Extend Effects package to cope with possibly failing operations, using

15− "if_valid", "if_error", etc

16−* At the REPL, "it" now refers to the previous expression

17−* Semantic colouring at the REPL. Turn this off with --nocolour.

18−* Some prettifying of error message

19−* The contents of ~/.idris/repl/init are run at REPL start-up.

20−* The REPL stores a command history in ~/.idris/repl/history

21−* The [a..b], [a,b..c], [a..], and [a,b..] syntax now pass the totality

22− checker and can thus be used in types. The [x..] syntax now returns an

23− actually infinite stream.

24−

25−Internal changes

26−

27−* New module/dependency tree checking

28−* New parser implementation with more precise errors

29−* Improved type class resolution

30−* Compiling Nat via GMP integers

31−* Performance improvements in elaboration

32−* Various REPL commands to support interactive editing, and a client/server

33− mode to allow external invocation of REPL commands.

34−

35−New in 0.9.9:

36−-------------

37−

38−* Apply functions by return type, rather than with arguments:

39− "t <== f" means "apply f with arguments such that it returns a value

40− of type t"

41−* Allow the result type of a rewrite to be specified

42−* Allow names to be attached to provisional definitions

43− lhs ?= {name} rhs -- generates a lemma called 'name' which makes the

44− types of the lhs and rhs match. {name} is optional - a unique name is

45− generated if it is absent.

46−* Experimental LLVM backend

47−* Added Data.HVect module

48−* Fix fromInteger to take an Integer, rather than an Int

49−* Integer literals for Fin

50−* Renamed O to Z, and fO to fZ

51−* Swapped Vect arguments, now Vect : Nat -> Type -> Type

52−* Added DecEq instances

53−* Add 'equiv' tactic, which rewrites a goal to an equivalent (convertible) goal

54−

55−Internal changes

56−

57−* Add annotation for unification traces

58−* Add 'mrefine' tactic for refining by matching against a type

59−* Type class resolution fixes

60−* Much faster coverage checking

61−

62−New in 0.9.8:

63−-------------

64−

65−User visible changes:

66−

67−* Added "rewrite ... in ..." construct

68−* Allow type class constraints in 'using' clauses

69−* Renamed EFF to EFFECT in Effect package

70−* Experimental Java backend

71−* Tab completion in REPL

72−* Dynamic loading of C libraries in the interpreter

73−* Testing IO actions at the REPL with :x command

74−* Improve rendering of :t

75−* Fixed some INTERNAL ERROR messages

76−

77−Internal changes:

78−

79−* Fix non-linear pattern checking

80−* Improved name disambiguation

81−* More flexible unification and elaboration of lambdas

82−* Various unification and totality checking bug fixes

83−

84−New in 0.9.7:

85−-------------

86−

87−User visible changes:

88−

89−* 'implicit' keyword, for implicit type conversion

90−* Added Effects package

91−* Primitives for 8,16,32 and 64 bit integers

92−

93−Internal changes:

94−

95−* Change unification so that it keeps track of failed constraints in case

96− later information helps to resolve them

97−* Distinguishing parameters and indices in data types

98−* Faster termination/coverage checking

99−* Split 'javascript' target into 'javascript' and 'node'

100−

101−New in 0.9.6:

102−-------------

103−

104−User visible changes:

105−

106−* The type of types is now 'Type' rather than 'Set'

107−* Forward declarations of data allowed

108− - supporting induction recursion and mutually recursive data

109−* Type inference of definitions in 'where' clauses

110− - Provided that the type can be completely determined from the first

111− application of the function (in the top level definition)

112−* 'mutual' blocks added

113− - effect is to elaborate all types of declarations in the block before

114− elaborating their definitions

115− - allows inductive-recursive definitions

116−* Expression inspected by 'with' clause now abstracted from the goal

117− - i.e. "magic" with

118−* Implicit arguments will be added automatically only if their initial

119− letter is lower case, or they are in a using declaration

120−* Added documentation comments (Haddock style) and ':doc' REPL command

121−* Pattern matching on strings, big integers and characters

122−* Added System.Concurrency modules

123−* Added 'postulate' declarations

124−* Allow type annotations on 'let' tactic

125−* EXPERIMENTAL JavaScript generation, with '--target javascript' option

126−

127−Internal changes:

128−

129−* Separate inlining methods at compile-time and run-time

130−* Fixed nested parameters blocks

131−* Improve efficiency of elaborator by:

132− - only normalising when necessary

133− - reducing backtracking with resolving ambiguities

134−* Better compilation of case trees

135−

136−New in 0.9.5:

137−-------------

138−

139−User visible changes:

140−

141−* Added codata

142− - as data declarations, but constructor arguments are evaluated lazily

143− - functions which return a codata type do not reduce at compile time

144−* Added 'parameters' blocks

145−* Allow local data definitions in where blocks

146−* Added '%default' directive to declare total-by-default or partial-by-default

147− for functions, and a corresponding "partial" reserved words to mark functions

148− as allowed to be partial. Also "--total" and "--partial" added as command

149− line options.

150−* Command line option "--warnpartial" for flagging all undeclared

151− partial functions, without error.

152−* New termination checker supporting mutually recursive definitions.

153−* Added ':load' command to REPL, for loading a new file

154−* Added ':module' command to REPL, for adding modules

155−* Renamed library modules (now have initial capital)

156−

157−Internal changes:

158−

159−* Several improvements and fixes to unification

160−* Added collapsing optimisation and more aggressive erasure

161−

162−New in 0.9.4:

163−-------------

164−

165−User visible changes:

166−

167−* Simple packaging system

168−* Added --dumpc flag for displaying generated code

169−

170−Internal changes:

171−

172−* Improve overloading resolution (especially where this is a type error)

173−* Various important bug fixes with evaluation and compilation

174−* More aggressive compile-time evaluation

175−

176−New in 0.9.3:

177−-------------

178−

179−User visible changes:

180−

181−* Added binding forms to syntax rules

182−* Named class instances

183−* Added ':set' command, with options 'errorcontext' for displaying local

184− variables in scope when a unification error occurs, and 'showimplicits'

185− for displaying elaborated terms in full

186−* Added '--errorcontext' command line switch

187−* Added ':proofs' and ':rmproofs' commands

188−* Various minor REPL improvements and fixes

189−

190−Internal changes:

191−

192−* Completely new run time system (not based on Epic or relying on Boehm GC)

193−* Normalise before forcing to catch more forceable arguments

194−* Types no longer exported in normal form

195−* Try to resolve overloading by inspecting types, rather than full type

196− checking

197−

198−New in 0.9.2:

199−-------------

200−

201−User visible changes:

202−

203−* backtick notation added: x `foo` y ==> foo x y

204−* case expressions allowed in type signatures

205−* Library extensions in prelude.vect and prelude.algebra

206−* malloc/trace_malloc added to builtins.idr

207−

208−Internal changes:

209−

210−* Some type class resolution fixes

211−* Several minor bug fixes

212−* Performance improvements in resolving overloading and type classes

213−

214−New in 0.9.1:

215−-------------

216−

217−User visible changes:

218−

219−* DSL notation, for overloading lambda and let bindings

220−* Dependent records, with projection and update

221−* Totality checking and 'total' keyword

222−* Auto implicits and default argument values {auto n : T}, {default val n : T}

223−* Overlapping type class instances disallowed

224−* Many extensions to prelude.nat and prelude.list libraries (mostly thanks to

225− Dominic Mulligan)

226−* New libraries: control.monad.identity, control.monad.state

227−* Small improvements in error reporting

228−

229−Internal changes:

230−

231−* Faster compilation (only compiling names which are used)

232−* Better type class resolution

233−* Lots of minor bug fixes

234−

235−0.1.x to 0.9.0:

236−

237−Complete rewrite. User visible changes:

238−

239−* New proof/tactics syntax

240−* New syntax for pairs/dependent pairs

241−* Indentation-significant syntax

242−* Added type classes

243−* Added where clauses

244−* Added case expressions, pattern matching let and lambda

245−* Added monad comprehensions

246−* Added cumulativity and universe checking

247−* Ad-hoc name overloading

248− - Resolved by type or explicit namespace

249−* Modules (Haskell-style)

250−* public, abstract and private access to functions and types

251−* Separate type-checking

252−* Improved interactive environment

253−* Replaced 'do using' with Monad class

254−* Extended syntax macros

255−

256−Internal changes:

257−

258−* Everything :-)

259−* All definitions (functions, classes and instances) are elaborated to top

260− level, fully explicit, data declarations and pattern matching definitions,

261− which are verified by a minimal type checker.

262−

263−This is the first release of a complete reimplementation. There will be bugs.

264−If you find any, please do not hesitate to contact Edwin Brady

265−(ecb10@st-andrews.ac.uk).

266−

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

3+

4+# New in 1.3.2

5++ Documentation added to proof section

6+

7+## Library updates

8++ `openFile` opens the file in binary mode on Windows.

9++ Added library functions `clockTime` and `fRemove`

10+

11+## Tool updates

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.

16+

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.

22+

23+# New in 1.3.1

24+

25+## Tool updates

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

29+

30+# New in 1.3.0

31+

32+## Language updates

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.

35+

36+## Library updates

37+

38++ Changed rndInt in Effect.Random so that it does not alternate between odd

39+ and even.

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.

45+

46+## Tool updates

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

49+ abnormally.

50++ Idris now builds with GHC 8.4.

51++ In the C backend, the representation of Idris values at runtime has been reworked.

52+

53+# New in 1.2.0

54+

55+## Language updates

56+

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

64+ ``(1 `plus`)``.

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.,

70+ ```idris

71+ LTB : Nat -> Type

72+ LTB b = DPair Nat (\ n => LT n b)

73+

74+ implementation [uninhabltb] Uninhabited (LTB Z) where

75+ uninhabited (MkDPair n prf) = absurd prf

76+ ```

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.

85+ ```idris

86+ intMax : IO Int

87+ intMax = foreign FFI_C "#INT_MAX" (IO Int)

88+ ```

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

91+ expose a symbol.

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.

94+ ```idris

95+ do …

96+ let Just x = expr | Nothing => empty

97+ …

98+ ```

99+ This means that a `with`-application (using `|`) cannot be used in that

100+ position anymore.

101+

102+## Library Updates

103+

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.

140+

141+## Tool Updates

142+

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

149+ in LaTeX.

150++ Errors and warnings now consistently have the following format:

151+ ```idris

152+ reg068.idr:1:6-8:

153+ |

154+ 1 | data nat : Type where --error

155+ | ~~~

156+ Main.nat has a name which may be implicitly bound.

157+ This is likely to lead to problems!

158+ ```

159+ The code is highlighted when highlighting information is available. How

160+ much highlighting information is available depends on where the error

161+ occurred.

162++ The parser provider has been switched from Trifecta to Megaparsec. This

163+ could possibly cause some subtle deviations in parsing from previous

164+ versions of Idris.

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

171+ `Foo.idr:9:7-16:`.

172+

173+## Packaging Updates

174+

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

179+ flags.

180+

181+# New in 1.1.1

182+

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

186+

187+# New in 1.1.0

188+

189+## Library Updates

190+

191++ Added `Text.PrettyPrint.WL` an implementation of the Wadler-Leijen

192+ Pretty-Print algorithm. Useful for those wishing to pretty print

193+ things.

194++ Added `Text.Lexer` and `Text.Parser` to `contrib`. These are small libraries

195+ for implementing total lexical analysers and parsers.

196++ New instances:

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`.

204+

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`.

208+

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`.

212+

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`.

217+

218+## Tool Updates

219+

220++ New JavaScript code generator that uses an higher level intermediate

221+ representation.

222+

223++ Various optimizations of the new JavaScript code generator.

224+

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.

228+

229+

230+# New in 1.0

231+

232++ It's about time

233+

234+# New in 0.99.2

235+

236+## Library Updates

237+

238++ Added `Data.Buffer` to `base`. This allows basic manipulation of mutable

239+ buffers of `Bits8`, including reading from and writing to files.

240+

241+## Tool Updates

242+

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.

245+

246+## Miscellaneous Updates

247+

248++ Documentation updates for the new `Control.ST` library

249++ Various stability/efficiency fixes

250+

251+# New in 0.99.1:

252+

253+## Language updates

254+

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`

261+ function

262+

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!

270+

271+## Tool Updates

272+

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`

278+ persist.

279+

280++ New REPL command `:!` that runs an external shell command.

281+

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.

284+

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)`).

288+

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

292+ package directory.

293+

294+## Library Updates

295+

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.

302+

303+# New in 0.99:

304+

305+## Language updates

306+

307+* `record` syntax now allows updating fields, including nested fields,

308+ by applying a function using the `$=` operator. For example:

309+

310+ ```idris

311+ record Score where

312+ constructor MkScore

313+ correct : Nat

314+ attempted : Nat

315+

316+ record GameState where

317+ constructor MkGameState

318+ score : Score

319+ difficulty : Nat

320+

321+ correct : GameState -> GameState

322+ correct st = record { score->correct $= (+1),

323+ score->attempted $= (+1) } st

324+ ```

325+

326+* Implicit parameter to interfaces are now allowed. For example:

327+

328+ ```idris

329+ interface Shows (ts : Vect k Type) where

330+ shows : HVect ts -> Vect k String

331+ ```

332+ In this interface, `k` is an implicit parameter, but previously needed to

333+ be explicit

334+

335+

336+## Library updates

337+

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.

348+

349+* Idris packages are now installed within a sub-directory `libs` of Idris' data directory, before they were installed in the directory's root.

350+

351+## Tool updates

352+

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`.

364+

365+## Miscellaneous updates

366+

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.

370+

371+## UI Changes

372+

373+* The :e command can now handle an $EDITOR with arguments in it, like "emacs -nw"

374+

375+

376+# New in 0.12:

377+

378+## Language updates

379+

380+* `rewrite` can now be used to rewrite equalities on functions over

381+ dependent types

382+* `rewrite` can now be given an optional rewriting lemma, with the syntax

383+ `rewrite [rule] using [rewrite_lemma] in [scope]`.

384+

385+* Reorganised elaboration of `implementation`, so that interfaces with

386+ dependencies between methods now work more smoothly

387+

388+* Allow naming of parent implementations when defining an implementation.

389+ For example:

390+

391+ ```

392+ [PlusNatSemi] Semigroup Nat where

393+ (<+>) x y = x + y

394+

395+ [MultNatSemi] Semigroup Nat where

396+ (<+>) x y = x * y

397+

398+ -- use PlusNatSemi as the parent implementation

399+ [PlusNatMonoid] Monoid Nat using PlusNatSemi where

400+ neutral = 0

401+

402+ -- use MultNatSemi as the parent implementation

403+ [MultNatMonoid] Monoid Nat using MultNatSemi where

404+ neutral = 1

405+ ```

406+

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).

411+

412+* Experimentally, allow named implementations to be available by default in a

413+ block of declarations with `using` notation. For example:

414+

415+ ```

416+ using implementation PlusNatMonoid

417+ test : Nat -> Nat

418+ test x = x <+> x <+> neutral

419+ ```

420+

421+* Constraint arguments can now appear anywhere in function types, not just

422+ at the top level or after an implicit argument binding.

423+

424+* Experimental extended `with` syntax, which allows calling functions defined

425+ in a with block directly. For example:

426+

427+ ```

428+ data SnocList : List a -> Type where

429+ Empty : SnocList []

430+ Snoc : SnocList xs -> SnocList (xs ++ [x])

431+

432+ snocList : (xs : List a) -> SnocList a

433+

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

438+ ```

439+

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`.

443+

444+* Added `%fragile` directive, which gives a warning and a message when a

445+ fragile name is referenced. For use in detailing fragile APIs.

446+

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.

450+

451+* The totality checker now looks under `if...then...else` blocks when checking

452+ for productivity.

453+

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

457+ is needed.

458+

459+## Library updates

460+

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

467+ between processes

468+

469+## iPKG Updates

470+

471+* Taking cues from cabal, the `iPKG` format has been extended to

472+ include more package metadata information. The following fields

473+ have been added:

474+

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.

483+

484+

485+## Miscellaneous updates

486+

487+* The Idris man page is now installed as part of the cabal/stack build process.

488+

489+* Improved startup performance by reducing the processing of an already imported

490+ module that has changed accessibility.

491+

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.

497+

498+* Remove deprecated options `--ideslave` and `--ideslave-socket`. These options

499+ were replaced with `--ide-mode` and `--ide-mode-socket` in 0.9.17

500+

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.

504+

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

509+ prevents this.

510+

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"``.

516+

517+## Reflection changes

518+

519+* The implicit coercion from String to TTName was removed.

520+

521+* Decidable equality for TTName is available.

522+

523+# New in 0.11

524+

525+## Updated export rules

526+

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

534+ as before.

535+* Exported types can only refer to other exported names

536+* Publicly exported definitions can only refer to publicly exported names

537+

538+## Improved C FFI

539+

540+* Idris functions can now be passed as callbacks to C functions or wrapped in a

541+ C function pointer.

542+* C function pointers can be called.

543+* Idris can access pointers to C globals.

544+

545+## Effects

546+

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)

549+

550+## Elaborator reflection updates

551+

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

557+ constructors.

558+

559+## Minor language changes

560+

561+* The `[static]` annotation is changed to `%static` to be consistent with the

562+ other annotations.

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.:

566+

567+ ```

568+ append : {n,m,a:_} -> Vect n a -> Vect m a -> Vect (n + m) a

569+ ```

570+

571+ Only names which are used explicitly in the type need to be bound, e.g.:

572+

573+ ```

574+ Here : {x, xs : _} -> Elem x (x :: xs)

575+ ```

576+

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

579+ bound).

580+

581+ You can still implicitly bind with 'using':

582+

583+ ```

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)

588+ ```

589+

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:

593+

594+ ```

595+ using (xs : Vect n a)

596+ bad : Elem x xs -> Elem x (y :: xs)

597+ ```

598+

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:

612+

613+ ```

614+ (a : Type ** n : Nat ** Vect n a)

615+ ```

616+

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

619+

620+## External Dependencies

621+

622+* Curses has been removed as an external dependency.

623+

624+# New in 0.10

625+

626+* `class` and `instance` are now deprecated keywords. They have been replaced by

627+ `interface` and `implementation` respectively. This is to properly reflect

628+ their purpose.

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.

637+

638+# New in 0.9.20

639+

640+## Language updates

641+

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.

659+

660+## Library updates

661+

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

669+ programmes.

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

673+ Effectful programs.

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

678+ that they may fail.

679+

680+## Tool updates

681+

682+* Records are now shown as records in `:doc`, rather than as the underlying

683+ datatype

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.

693+

694+## Miscellaneous updates

695+

696+* Disable the deprecation warnings for %elim and old-style tactic scripts with

697+ the `--no-elim-deprecation-warnings` and `--no-tactic-deprecation-warnings`

698+ flags.

699+

700+# New in 0.9.19

701+

702+* The Idris Reference manual has been fleshed out with content originally found

703+ on the GitHub wiki.

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

713+ compiler output

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`

722+ functions

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

733+

734+# New in 0.9.18:

735+

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

740+ settings.

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

745+ compatibility)

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:

759+

760+ ```

761+ case Vect.Nil {a=Nat} of { (x::xs) impossible ; [] => True }

762+ ```

763+

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`

778+ keyword.

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

783+ desugaring.

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

787+ datatypes.

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

793+

794+# New in 0.9.17

795+

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

800+ hole stack

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

812+ `Matrix.(<:>)`.

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

824+ of a type

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.

841+

842+# New in 0.9.16

843+

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

847+ top level.

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

855+ error.

856+* Better Unicode support for the JavaScript/Node codegen

857+* `:search` and `:apropos` commands can now be given optional package lists to

858+ search.

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

862+ coverage checking.

863+* Modules can now have API documentation strings.

864+

865+# New in 0.9.15

866+

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

873+ prover.

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

877+ large expressions.

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

888+ HTML highlighting

889+* Naming of data and type constructors is made consistent across the standard

890+ library (see #1516)

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

895+ as code examples.

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

899+ Engine style)

900+

901+# New in 0.9.14

902+

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

908+ site

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.

919+

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

924+ environment.

925+* Better inference of unbound implicits

926+

927+# New in 0.9.13

928+

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

938+ program.js)

939+* Remove `:info` REPL command, subsume and enhance its functionality in the `:doc` command

940+* New (first class) nested record update/access syntax:

941+

942+ ```

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))

945+ ```

946+

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

956+ metavariable.

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

962+

963+## Internal changes

964+

965+* New implementation of erasure

966+

967+# New in 0.9.12

968+

969+* Proof search now works for metavariables in types, giving some interactive

970+ type inference.

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:

981+

982+ ```

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

987+ ```

988+

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

997+

998+# New in 0.9.11

999+

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

1024+ release.

1025+

1026+## Internal changes

1027+

1028+* Faster elaboration

1029+* Smaller .ibc files

1030+* Pretty-printer now used for all term output

1031+

1032+# New in 0.9.10

1033+

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/`.

1055+

1056+## Internal changes

1057+

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.

1066+

1067+# New in 0.9.9

1068+

1069+## User visible changes

1070+

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

1085+

1086+## Internal changes

1087+

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

1092+

1093+# New in 0.9.8

1094+

1095+## User visible changes

1096+

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

1106+

1107+## Internal Changes

1108+

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

1113+

1114+# New in 0.9.7

1115+

1116+## User visible changes

1117+

1118+* `implicit` keyword, for implicit type conversion

1119+* Added Effects package

1120+* Primitives for 8,16,32 and 64 bit integers

1121+

1122+## Internal Changes

1123+

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'

1129+

1130+# New in 0.9.6

1131+

1132+## User visible changes

1133+

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

1154+

1155+## Internal Changes

1156+

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

1163+

1164+# New in 0.9.5

1165+

1166+## User visible changes

1167+

1168+* Added codata

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

1176+ options.

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)

1183+

1184+## Internal changes

1185+

1186+* Several improvements and fixes to unification

1187+* Added collapsing optimisation and more aggressive erasure

1188+

1189+# New in 0.9.4:

1190+

1191+## User visible changes

1192+

1193+* Simple packaging system

1194+* Added `--dumpc` flag for displaying generated code

1195+

1196+## Internal changes

1197+

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

1201+

1202+# New in 0.9.3

1203+

1204+## User visible changes

1205+

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

1214+

1215+## Internal changes

1216+

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

1221+ checking

1222+

1223+# New in 0.9.2

1224+

1225+## User visible changes

1226+

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

1231+

1232+## Internal changes

1233+

1234+* Some type class resolution fixes

1235+* Several minor bug fixes

1236+* Performance improvements in resolving overloading and type classes

1237+

1238+# New in 0.9.1

1239+

1240+## User visible changes

1241+

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

1248+ Dominic Mulligan)

1249+* New libraries: `control.monad.identity`, `control.monad.state`

1250+* Small improvements in error reporting

1251+

1252+## Internal changes

1253+

1254+* Faster compilation (only compiling names which are used)

1255+* Better type class resolution

1256+* Lots of minor bug fixes

1257+

1258+# 0.1.x to 0.9.0

1259+

1260+Complete rewrite.

1261+

1262+## User visible changes

1263+

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

1280+

1281+## Internal changes

1282+

1283+* Everything :-)

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.

1287+

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).

CITATION.mdnew file+29

@@ -0,0 +1,29 @@

1+# Citing `Idris`

2+

3+If you use `Idris` in your work we would prefer it if you would use the following reference in your work.

4+

5+## BibTeX

6+

7+```bibtex

8+@article{JFP:9060502,

9+ author = {BRADY,EDWIN},

10+ title = {Idris, a general-purpose dependently typed programming language: Design and implementation},

11+ journal = {Journal of Functional Programming},

12+ volume = {23},

13+ issue = {05},

14+ month = {9},

15+ year = {2013},

16+ issn = {1469-7653},

17+ pages = {552--593},

18+ numpages = {42},

19+ doi = {10.1017/S095679681300018X},

20+ URL = {https://journals.cambridge.org/article_S095679681300018X},

21+}

22+```

23+

24+## Textual

25+

26+ EDWIN BRADY (2013). Idris, a general-purpose dependently typed

27+ programming language: Design and implementation. Journal of

28+ Functional Programming, 23, pp

29+ 552-593. doi:10.1017/S095679681300018X.

CONTRIBUTING.mdnew file+184

@@ -0,0 +1,184 @@

1+# Contributing to Idris-Dev

2+

3+The Idris Community welcomes pull requests, bug reporting, and bug squashing!

4+However, we cannot do it all ourselves, and want to make it as easy as possible to contribute changes to get things working.

5+Here are a few guidelines that we would like contributors to follow so that we can have a chance of keeping on top of things.

6+

7+## Getting Started

8+

9+1. Make sure you are familiar with [Git](https://git-scm.com/book).

10+1. Make sure you have a [GitHub account](https://github.com/signup/free).

11+1. Make sure you are familiar with: [Idris](https://eb.host.cs.st-andrews.ac.uk/writings/idris-tutorial.pdf).

12+1. Make sure you can install Idris:

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)

15+ * [Debian](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-Debian)

16+ * [Windows](https://github.com/idris-lang/Idris-dev/wiki/Idris-on-Windows)

17+

18+## Issue Reporting

19+

20+Before 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).

21+We do not want you wasting your time, duplicating somebody's work!

22+

23+### Template

24+Try as closely as possible to describe the issue, ensuring that it has sections that match the following headings:

25+> \# Steps to Reproduce

26+>

27+> \# Expected Behavior

28+>

29+> \# Observed Behavior

30+>

31+>

32+

33+In addition, please attach complete source files that exhibit the issue to quoting from them in the issue.

34+

35+### Feature Requests

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.

37+

38+## The Campsite Rule

39+

40+We try to follow the **campsite rule**: leave the code base in better condition than you found it.

41+Please clean up any messes that you find, and don't leave behind new messes for the next contributor.

42+

43+## Contributing to the default libraries.

44+

45+Idris ships with a set of packages in `libs/` that is provided as a default library.

46+

47++ `prelude` is a collection of basic definitions, automatically imported by Idris programs.

48++ `base` is tried and tested code that may be useful, and has seen active use in multiple projects.

49++ `contrib` is code that is experimental in design and that we want to test before possible inclusion in `base`.

50++ `effects` is a library which supports effectful programming.

51+

52+These packages should not be seen as the *standard* as when working with dependent types; we do not necessarily know how best to work with dependent types yet.

53+These packages offer functionality that can be built on top of when constructing Idris programs.

54+

55+Everything in prelude will be imported automatically, unless given the `--noprelude` option.

56+The contents of base are available with no special options, but modules must be imported.

57+The other two packages that ship with Idris, contrib and effects, require the use of the `-p` command-line argument to bring their contents into the include path.

58+

59+New contributions should be added to the contrib package (never directly to base or prelude!).

60+If they turn out to be widely applicable and useful, they may later be moved into base.

61+

62+As Idris is still being developed we are open to suggestions and changes that make improvements to these default packages.

63+Major changes to the library, or Idris itself, should be discussed first through the project's official channels of communication:

64+

65+1. The mailing List.

66+1. On our IRC Channel `#idris` on freenode, or

67+1. As an RFC in the issue tracker

68+

69+Developers then seeking to add content to Idris's prelude and default library, should do so through a PR where more discussions and refinements can be made.

70+

71+We do not want you wasting your time nor duplicating somebody's work!

72+

73+## Making Changes

74+

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/).

76+The steps are described below.

77+

78+### New contributors

79+

80+For those new to the project:

81+

82+1. Fork our [main development repository](https://github.com/idris-lang/Idris-dev) `idris-dev` on github e.g.

83+2. Clone your fork to your local machine:

84+

85+```

86+$ git clone git@github.com:<your github user name>/Idris-dev.git

87+```

88+

89+3. Add `idris-lang/Idris-dev` as a remote upstream

90+

91+```

92+$ git remote add upstream git@github.com:idris-lang/Idris-dev.git

93+```

94+

95+### Existing Contributors

96+

97+For those already contributing to the project:

98+

99+1. Ensure your existing clone is up-to-date with current `HEAD` e.g.

100+

101+```

102+$ git fetch upstream

103+$ git merge upstream/master

104+```

105+

106+### Remaining Steps

107+

108+The remaining steps are the same for both new and existing contributors:

109+

110+1. Create, and checkout onto, a topic branch on which to base you work.

111+ * This is typically the master branch.

112+ * Please avoid working on the `master` branch.

113+

114+```

115+$ git branch fix/master/my_contrib master

116+$ git checkout fix/master/my_contrib

117+```

118+

119+1. Make commits of logical units.

120+1. Check for unnecessary whitespace with

121+

122+```

123+$ git diff --check

124+```

125+

126+1. Make sure your commit messages are along the lines of:

127+

128+ Short (50 chars or less) summary of changes

129+

130+ More detailed explanatory text, if necessary. Wrap it to about 72

131+ characters or so. In some contexts, the first line is treated as the

132+ subject of an email and the rest of the text as the body. The blank

133+ line separating the summary from the body is critical (unless you omit

134+ the body entirely); tools like rebase can get confused if you run the

135+ two together.

136+

137+ Further paragraphs come after blank lines.

138+

139+ - Bullet points are okay, too

140+

141+ - Typically a hyphen or asterisk is used for the bullet, preceded by a

142+ single space, with blank lines in between, but conventions vary here

143+

144+1. Make sure you have added any necessary tests for your changes.

145+1. Run all the tests to ensure nothing else was accidentally broken.

146+

147+```

148+$ make test

149+```

150+

151+1. Push your changes to a topic branch in your fork of the repository.

152+

153+```

154+$ git push origin fix/master/my_contrib

155+```

156+

157+1. Go to GitHub and submit a pull request to `idris-dev`

158+

159+From there you will have to wait on one of the `idris-dev` committers to respond to the request.

160+This response might be an accept or some changes/improvements/alternatives will be suggest.

161+We do not guarantee that all requests will be accepted.

162+

163+## Increasing chances of acceptance.

164+

165+To help increase the chance of your pull request being accepted:

166+

167+1. Run the tests.

168+1. Update the documentation, the surrounding code, examples elsewhere, guides, whatever is affected by your contribution

169+1. Use appropriate code formatting for both Idris and Haskell.

170+

171+## Additional Resources

172+

173+* [Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki);

174+* [Zen Of Idris](https://github.com/idris-lang/Idris-dev/wiki/The-Zen-of-Idris);

175+* Idris FAQs: [Official](https://idris.readthedocs.io/en/latest/faq/faq.html); [Unofficial](https://github.com/idris-lang/Idris-dev/wiki/Unofficial-FAQ);

176+* [Idris Manual](https://github.com/idris-lang/Idris-dev/wiki/Manual);

177+* [Idris Tutorial](https://idris.readthedocs.io/en/latest/tutorial/index.html);

178+* [Idris News](https://www.idris-lang.org/news/);

179+* [other Idris docs](https://www.idris-lang.org/documentation/).

180+* [Using Pull Requests](https://help.github.com/articles/using-pull-requests)

181+* [General GitHub Documentation](https://help.github.com/).

182+

183+

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)

CONTRIBUTORS+218−17

@@ -1,28 +1,229 @@

11Thanks to the following for their help and contributions:

22

3−Ozgur Akgun

3+a3gis

4+Aaron Craelius

5+Adam Sandberg Eriksson

6+Adam Schønemann

7+Adolfo Ochagavía

48Ahmad Salim Al-Sibahi

5−Edward Chadwick Amsden

6−Nicola Botta

7−Edwin Brady

8−David Raymond Christiansen

9−Jason Dagit

10−Simon Fowler

9+Aistis Raulinaitis

10+Alex Feldman-Crough

11+Alex S. Queiroz e Silva

12+Alexander Berntsen

13+Alexander Shabalin

14+Alyssa Carter

15+Andreas Bogk

16+Andreas Reuleaux

17+Andrei Dziahel

18+Andrew Cann

19+Andrew Stewart Gibson

20+Andy Morris

21+Anthony Cantor

22+Anthony---faineance

23+Apostolis Xekoukoulotakis

24+Athan Clark

25+Bartosz Przygoda

26+Ben Gamari

27+Ben Sherman

28+ben-schulz

29+Benjamin Hodgson

30+Benjamin Saunders

31+Björn Aili

32+bmastenbrook

33+Brent Yorgey

34+Brian Koropoff

35+Brian McKenna

36+Bryn Keller

37+Caleb Case

38+Calvin Beck

39+Carsten König

40+Carter Charbonneau

41+Casper M. H. Holmgreen

42+cchantep

1143Cezar Ionescu

44+Chao-Hong Chen

45+Chetan Taralekar

46+Chris Allen

47+Chris Gibbs

48+Christopher Schwaab

49+Cliff Harvey

50+Cliff L. Biffle

51+Colin Adams

52+comco

53+Craig McLaughlin

54+cswords

55+Daniel Waterworth

56+Daniël Heres

57+Darin Morrison

58+David Feuer

59+David Kraeutmann

60+David Raymond Christiansen

61+defanor

62+Dennis Griffith

63+Dirk Ullrich

64+Dmitry Bushev

65+Dmitry Tsygankov

66+Dominic Mulligan

67+Dominik Peteler

68+Echo Nolan

69+Eduard Nicodei

70+Edward Amsden

71+Edward O'Callaghan

72+Edwin Brady

73+Eric Casteleijn

74+Eric Mertens

75+Eric Walkingshaw

76+Eric Weinstein

77+Erkin Batu Altunbaş

78+Ertugrul Söylemez

79+EvanR

80+Fabian Thorand

81+fiendfan1

82+Franklin Chen

83+Frederic Koehler

84+Friedrich von Never

85+Gabe McArthur

86+Gabor Greif

87+Gabriel Garcia

88+George Leontiev

89+Gleb Alexeyev

90+Google

91+Greg Anderson

92+Greg Pfeil

93+Guglielmo Fachini

94+Hannes Mehnert

95+Heath Johns

96+Heather

97+Hector A. Escobedo IV

98+identical snowflake

99+Ignas Vyšniauskas

100+Ilan Godik

101+Imuli

12102Irene Knapp

103+Jack Henahan

104+Jacob Mitchell

105+Jakob Brünker

106+Jan Bessai

107+Jan de Muijnck-Hughes

108+Jan Doms

109+Jan Stolarek

110+Jason Dagit

111+Jason Felice

112+Jason Gross

113+Jean-Remi Desjardins

114+Jeff Hemphill

115+Jefferson Carpenter

116+Jens Petersen

117+Jeremy W. Sherman

118+jhegedus42

119+joe9

120+Johannes Griebler

121+John Connor

122+John Dobronszki

123+John Wiegley

124+Jon Atack

125+Jonas De Vuyst

126+Jonas Westerlund

127+Jonathan Sterling

128+Joomy Korkut

129+Jorge Acereda

130+Joseph Huang

131+Josh Vera

132+JP Smith

133+Juliusz Chroboczek

134+Jurriën Stutterheim

135+Jürgen Peters

136+Karlos Kaeeikaas

137+Kester Tong

138+lambdadomain

139+Langston Barrett

140+Leif Warner

141+Leon Schoorl

142+Luke Palmer

143+Mark Farrell

144+Markus Klink

145+Markus Pfeiffer

146+Martin Baker

13147Mathnerd314

14−Hannes Mehnert

148+Mattias Lundell

149+Matvey B. Aksenov

150+Matúš Tejiščák

151+Maxim Ivanov

15152Mekeor Melire

16153Melissa Mozifian

17−Dominic Mulligan

154+Melvar Chen

155+Michael A. Smith

156+Michael Bernstein

157+Michael Gilliland

158+Michael Hensler

159+Michael Maloney

160+Michael McGirr

161+Michael Morgan

162+Michael Thompson

163+Michael Weiss

164+Miikka Koskinen

165+Mitchell Rosen

166+Miëtek Bak

167+Mort Yao

168+Nathan Dinsmore

169+Nicola Botta

170+Niklas Larsson

171+Norbert Melzer

172+Oskar Wickström

173+Ozgur Akgun

174+Patrick Hilhorst

175+Patrik Jansson

176+Paul Koerbitz

177+Per Fredelius

178+Peter Minten

179+Philip Rasmussen

180+PoroCYon

18181raichoo

19−Tom Prince

182+Reynir Björnsson

183+Ricky Elrod

184+Robert Clipsham

185+Robert Edström

186+Ross Meikleham

187+Rui Barreiro

188+Ryan Scott

189+Sam Elliott

190+Sam T

191+Saurabh Rawat

192+Sean Hunt

193+Sebastian de Bellefon

194+Sebastian Dröge

20195Seo Sanghyeon

21−Benjamin Saunders

196+Sergei Trofimovich

197+Shane Pearman

198+Shea Levy

199+Simon Fowler

22200startling

23−Chetan T

24−Dirk Ullrich

25−Leif Warner

26−Daniel Waterworth

27−Jonas Westerlund

28−Reynir Reynisson

201+Stefan Bleibinhaus

202+stepcut

203+Stephen Drodge

204+Steven Shaw

205+Stuart Gale

206+suhorng

207+Sune Alkærsig

208+Sven Koschnicke

209+Taran Lynn

210+tdidriksen

211+Tenor Biel

212+Thomas Cooper

213+Thomas Scholtes

214+Tim Dysinger

215+Tim McGilchrist

216+Timo Petteri Sinnemäki

217+Tom Prince

218+TorosFanny

219+Trevor Elliott

220+uwap

221+Vitaly Bragilevsky

222+Vyacheslav Shebanov

223+xged

224+XIE Yuheng

225+Yacine Hmito

226+Zack Grannan

227+Zheng Jihui

228+zjhmale

229+Сухарик

INSTALL.mdnew file+153

@@ -0,0 +1,153 @@

1+# Idris Installation Guide

2+

3+Copyright (C) 2015, The Idris Community

4+

5+## Installing Idris from Hackage

6+

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).

13+

14+## Installing Development Versions

15+

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

19+sandbox are

20+[available on the Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki/Installing-an-Idris-Development-version-in-a-sandbox).

21+

22+To configure, edit config.mk. The default values should work for most

23+people.

24+

25+Idris is built using a Makefile common targets include:

26+

27+* `make` This will install everything using cabal and typecheck the

28+ libraries.

29+* `make test` This target execute the test suite.

30+* `make relib` This target will typecheck and recompile the standard

31+ library.

32+

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`.

38+

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`

42+

43+To build with `libffi` and `libGMP` by default, create a `custom.mk`

44+file and add the following line to it:

45+

46+`CABALFLAGS += -f FFI -f GMP`

47+

48+The file `custom.mk-alldeps` is a suitable example.

49+

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

53+`custom.mk`:

54+

55+`CI = true`

56+

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

59+contribute.

60+

61+## Experimental Support for Building with Stack

62+

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.

67+

68+This installation has been tested on Ubuntu 16.04.1 LTS, and the current

69+NixOS unstable.

70+

71+*Important* Stack will not install any external dependencies required

72+to build Idris. Before you try stack please ensure you have the

73+correct dependencies.

74+

75+To build Idris with stack use the following command:

76+

77+* `stack build`

78+

79+To install Idris:

80+

81+* `stack install`

82+

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.

88+

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).

92+

93+On NixOS, please use the following command instead, to make sure

94+the required libraries and header files are available:

95+

96+* `stack build --nix`

97+

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.

101+

102+A safer way to do this is therefore to recursively delete all the `*.ibc`

103+files from the `libs/` folder.

104+

105+On Linux(or similar) you can do this with

106+

107+ find . -name "*.ibc" -exec rm -rf {} \;

108+

109+### System GHC

110+

111+The flag `--system-ghc` can be added to enforce use of your system's

112+version of GHC.

113+

114+### `libGMP` and `libFFI`

115+

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.

119+

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:

125+

126+```

127+PKG_CONFIG_PATH=/usr/local/opt/libffi/lib/pkgconfig stack build

128+```

129+

130+## Issue with GHC on Ubuntu/Fedora

131+

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.

134+

135+See the following GHC issue page for more information:

136+

137+ <https://gitlab.haskell.org/ghc/ghc/issues/15397>

138+

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:

142+

143+> error while loading shared libraries: libffi.so.7: cannot open shared object file: No such file or directory

144+

145+A workround for this bug is to override the used libffi version (this is what we use on CI):

146+

147+```bash

148+export LD_PRELOAD=/opt/ghc/${GHCVER}/lib/ghc-${GHCVER}/rts/libffi.so.7

149+```

150+

151+## GHC 8.6

152+

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.

Makefile+55−18

@@ -1,45 +1,82 @@

1−.PHONY: build configure doc install linecount nodefault pinstall lib_clean relib test

1+.PHONY: build configure doc install linecount nodefault pinstall lib_clean relib fast test_js test_c stylize test test_clean lib_doc lib_doc_clean user_doc_html user_doc_pdf user_docs

2+

3+ARGS=

4+TEST-JOBS=

5+TEST-ARGS=

26

37include config.mk

48-include custom.mk

59

10+ifdef CI

11+CABALFLAGS += -f CI

12+ifndef APPVEYOR

13+TEST-ARGS += --color always

14+endif

15+endif

16+

617install:

7− $(CABAL) install $(CABALFLAGS)

18+ $(CABAL) v1-install $(CABALFLAGS)

819

920pinstall: CABALFLAGS += --enable-executable-profiling

1021pinstall: dist/setup-config

11− $(CABAL) install $(CABALFLAGS)

22+ $(CABAL) v1-install $(CABALFLAGS)

1223

1324build: dist/setup-config

14− $(CABAL) build $(CABALFLAGS)

25+ $(CABAL) v1-build $(CABALFLAGS)

26+

27+test: doc test_c stylize

1528

16−test:

17− $(MAKE) -C test IDRIS=../dist/build/idris

29+stylize:

30+ ./stylize.sh

1831

19−test_java:

20− $(MAKE) -C test IDRIS=../dist/build/idris test_java

32+test_c:

33+ $(CABAL) v1-test $(ARGS) --test-options \

34+ "$(TEST-ARGS) --rerun-update +RTS -N$(TEST-JOBS) -RTS"

2135

22−test_llvm:

23− $(MAKE) -C test IDRIS=../dist/build/idris test_llvm

36+test_js:

37+ $(CABAL) v1-test $(ARGS) --test-options \

38+ "$(TEST-ARGS) --node --rerun-update +RTS -N$(TEST-JOBS) -RTS"

2439

25−test_all:

26− $(MAKE) test

27− $(MAKE) test_llvm

28− $(MAKE) test_java

40+test_update:

41+ $(CABAL) v1-test $(ARGS) --test-options \

42+ "$(TEST-ARGS) --accept +RTS -N$(TEST-JOBS) -RTS"

43+

44+test_clean:

45+ rm -f test/*~

46+ rm -f test/*/output

2947

3048lib_clean:

3149 $(MAKE) -C libs IDRIS=../../dist/build/idris/idris RTS=../../dist/build/rts/libidris_rts clean

3250

3351relib: lib_clean

34− $(CABAL) install $(CABALFLAGS)

52+ $(CABAL) v1-install $(CABALFLAGS)

3553

3654linecount:

37− wc -l src/Idris/*.hs src/Core/*.hs src/IRTS/*.hs src/Pkg/*.hs

55+ wc -l src/Idris/*.hs src/Idris/Elab/*.hs src/Idris/Core/*.hs src/IRTS/*.hs src/Pkg/*.hs src/Util/*.hs

3856

3957#Note: this doesn't yet link to Hackage properly

4058doc: dist/setup-config

41− $(CABAL) haddock --executables --hyperlink-source --html --hoogle --html-location="http://hackage.haskell.org/packages/archive/\$$pkg/latest/doc/html" --haddock-options="--title Idris"

59+ $(CABAL) v1-haddock --hyperlink-source --html --hoogle --html-location="https://hackage.haskell.org/packages/archive/\$$pkg/latest/doc/html" --haddock-options="--title Idris"

60+

61+lib_doc:

62+ $(MAKE) -C libs IDRIS=../../dist/build/idris/idris doc

63+

64+lib_doc_clean:

65+ $(MAKE) -C libs IDRIS=../../dist/build/idris/idris doc_clean

66+

67+user_docs: user_doc_html user_doc_pdf

68+

69+user_doc_clean:

70+ $(MAKE) -C docs clean

71+

72+user_doc_html:

73+ $(MAKE) -C docs html

74+

75+user_doc_pdf:

76+ $(MAKE) -C docs latexpdf

4277

78+fast:

79+ $(CABAL) v1-install $(CABALFLAGS) --ghc-option=-O0

4380

4481dist/setup-config:

45− $(CABAL) configure $(CABALFLAGS)

82+ $(CABAL) v1-configure $(CABALFLAGS)

READMEdeleted−20

@@ -1,20 +0,0 @@

1−Idris (http://idris-lang.org/) is an experimental functional programming

2−language with dependent types.

3−

4−To configure, edit config.mk. The default values should work for most people.

5−

6−To install, type 'make'. This will install everything using cabal and

7−typecheck the libraries.

8−

9−To run the tests, type 'make test' which will execute the test suite, and

10−'make relib', which will typecheck and recompile the standard library.

11−

12−Idris has optional buildtime dependencies on the C libraries llvm-3.3 and libffi. If you would like to use the features that these enable, be sure these are compiled for the same architecture as your Haskell compiler (e.g. 64 bit libraries for 64 bit ghc). By default, Idris builds without them. To build with them, pass the flags -f LLVM and -f FFI, respectively.

13−

14−To build with LLVM and libffi by default, create custom.mk or add the following line to it:

15−CABALFLAGS += -f LLVM -f FFI

16−The file custom.mk-alldeps is a suitable example.

17−

18−Idris has a runtime dependency on libgmp, and on Boehm GC (libgc) when using the LLVM codegen. These are needed for linking into compiled programs, so be sure these are compiled for Idris's default target architecture (usually 64 bit on x86_64 systems).

19−

20−The Idris wiki contains instructions for building on various platforms and for getting involved with development. It is located at https://github.com/idris-lang/Idris-dev/wiki .

README.mdnew file+49

@@ -0,0 +1,49 @@

1+# Idris

2+

3+[](https://travis-ci.org/idris-lang/Idris-dev)

4+[](https://ci.appveyor.com/project/idrislang/idris-dev)

5+[](https://readthedocs.org/projects/idris/?badge=latest)

6+[](https://hackage.haskell.org/package/idris)

7+[](https://stackage.org/lts/package/idris)

8+[](https://stackage.org/nightly/package/idris)

9+[](https://www.irccloud.com/invite?channel=%23idris&hostname=irc.freenode.net&port=6697&ssl=1)

10+

11+Idris (https://idris-lang.org/) is a general-purpose functional programming

12+language with dependent types.

13+

14+## Installation Guides.

15+

16+This repository represents the latest development version of the

17+language, and may contain bugs that are being actively worked on. For

18+those who wish to use a more stable version of Idris please consider

19+installing the latest version that has been released on Hackage.

20+Installation instructions for various platforms can be

21+[found on the Idris Wiki](https://github.com/idris-lang/Idris-dev/wiki/Installation-Instructions).

22+

23+More information about building Idris from source has been detailed in the [Installation Guide](INSTALL.md)

24+

25+## Code Generation

26+

27+Idris has support for external code generators. Supplied with the distribution

28+is a C code generator to compile executables, and a JavaScript code generator

29+with support for node.js and browser JavaScript.

30+

31+More information about [code generators can be found on the wiki](https://idris.readthedocs.io/en/latest/reference/codegen.html).

32+

33+## More Information

34+

35+If you would like to find out more information, or ask questions, we

36+currently have a [Wiki](https://github.com/idris-lang/Idris-dev/wiki);

37+a [mailing list](https://groups.google.com/forum/#!forum/idris-lang),

38+and an `IRC` channel `#idris` on freenode. To join the IRC channel,

39+point your irc client to `chat.freenode.net` then `/join #idris`.

40+

41+For those further interested in using Idris for projects, the

42+[Idris Hackers](https://github.com/idris-hackers) GitHub organisation is

43+where some interesting projects are being hosted.

44+

45+For those interested in contributing to Idris directly we kindly ask that

46+prospective developers please consult the [Contributing Guide](CONTRIBUTING.md) first.

47+

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 @@

1+# Release Checks

2+

3+Things to be checked, or done before a release is made.

4+

5+## Final Checks

6+

7++ [ ] Do the tests run to completion?

8++ [ ] Can samples build?

9++ [ ] Is `man/idris.1` up-to-date?

10+

11+## Version Numbers

12+

13++ [ ] `man/idris.1`.

14++ [ ] `docs/conf.py`.

15++ [ ] `docs/listing/idris-prompt-helloworld.txt`.

16++ [ ] `docs/listing/idris-prompt-interp.txt`.

17++ [ ] `docs/listing/idris-prompt-start.txt`.

18++ [ ] `idris.cabal`.

19+

20+## Tag Release

21+

22++ [ ] Finalise and check `CHANGELOG.md`.

23++ [ ] Tag the release.

24+

25+## Uploads

26+

27++ [ ] Push to GITHUB.

28++ [ ] Upload to Hackage.

29++ [ ] Upload package documentation to web site

30+

31+## Binaries

32+

33++ [ ] Generate Mac OS X Package.

34++ [ ] Prompt helpers to create:

35+ + [ ] Windows Binary.

36+ + [ ] HomeBrew Package.

37+

38+## Announcements

39+

40++ [ ] Update website.

41+ + [ ] Update web site with SHA256 hash of binary

42++ [ ] Email Mailing list.

43++ [ ] Make REDDIT post.

44++ [ ] Tweet

Setup.hs+207−41

@@ -1,22 +1,36 @@

11{-# LANGUAGE CPP #-}

2+

3+#if !defined(MIN_VERSION_Cabal)

4+# define MIN_VERSION_Cabal(x,y,z) 0

5+#endif

6+

27import Control.Monad

38import Data.IORef

9+import Control.Exception (SomeException, catch)

410

511import Distribution.Simple

12+import Distribution.Simple.BuildPaths

613import Distribution.Simple.InstallDirs as I

714import Distribution.Simple.LocalBuildInfo as L

815import qualified Distribution.Simple.Setup as S

916import qualified Distribution.Simple.Program as P

17+import Distribution.Simple.Utils

18+import Distribution.Compiler

1019import Distribution.PackageDescription

1120import Distribution.Text

21+import Distribution.Verbosity

1222

23+import System.Environment

1324import System.Exit

14−import System.FilePath ((</>), splitDirectories)

25+import System.FilePath ((</>), splitDirectories,isAbsolute)

1526import System.Directory

1627import qualified System.FilePath.Posix as Px

1728import System.Process

18−import qualified Data.Text as T

19−import qualified Data.Text.IO as TIO

29+

30+#if (MIN_VERSION_Cabal(2,0,0))

31+import Distribution.Types.UnqualComponentName

32+#endif

33+

2034

2135-- After Idris is built, we need to check and install the prelude and other libs

2236

@@ -35,7 +49,8 @@ idrisCmd local = ".." </> ".." </> buildDir local </> "idris" </> "idris"

3549-- Make Commands

3650

3751-- use GNU make on FreeBSD

38−#ifdef freebsd_HOST_OS

52+#if defined(freebsd_HOST_OS) || defined(dragonfly_HOST_OS)\

53+ || defined(openbsd_HOST_OS) || defined(netbsd_HOST_OS)

3954mymake = "gmake"

4055#else

4156mymake = "make"

@@ -43,46 +58,150 @@ mymake = "make"

4358make verbosity =

4459 P.runProgramInvocation verbosity . P.simpleProgramInvocation mymake

4560

61+#ifdef mingw32_HOST_OS

62+windres verbosity = P.runProgramInvocation verbosity . P.simpleProgramInvocation "windres"

63+#endif

4664-- -----------------------------------------------------------------------------

4765-- Flags

4866

49−usesLLVM :: S.ConfigFlags -> Bool

50−usesLLVM flags =

51− case lookup (FlagName "llvm") (S.configConfigurationsFlags flags) of

67+usesGMP :: S.ConfigFlags -> Bool

68+usesGMP flags =

69+ case lookupFlagAssignment (mkFlagName "gmp") (S.configConfigurationsFlags flags) of

5270 Just True -> True

5371 Just False -> False

54− Nothing -> True

72+ Nothing -> False

5573

56−usesGMP :: S.ConfigFlags -> Bool

57−usesGMP flags =

58− case lookup (FlagName "gmp") (S.configConfigurationsFlags flags) of

74+execOnly :: S.ConfigFlags -> Bool

75+execOnly flags =

76+ case lookupFlagAssignment (mkFlagName "execonly") (S.configConfigurationsFlags flags) of

5977 Just True -> True

6078 Just False -> False

61− Nothing -> True

79+ Nothing -> False

80+

81+isRelease :: S.ConfigFlags -> Bool

82+isRelease flags =

83+ case lookupFlagAssignment (mkFlagName "release") (S.configConfigurationsFlags flags) of

84+ Just True -> True

85+ Just False -> False

86+ Nothing -> False

87+

88+isFreestanding :: S.ConfigFlags -> Bool

89+isFreestanding flags =

90+ case lookupFlagAssignment (mkFlagName "freestanding") (S.configConfigurationsFlags flags) of

91+ Just True -> True

92+ Just False -> False

93+ Nothing -> False

94+

95+#if !(MIN_VERSION_Cabal(2,0,0))

96+mkFlagName :: String -> FlagName

97+mkFlagName = FlagName

98+#endif

99+

100+#if !(MIN_VERSION_Cabal(2,2,0))

101+lookupFlagAssignment :: FlagName -> FlagAssignment -> Maybe Bool

102+lookupFlagAssignment = lookup

103+#endif

62104

63105-- -----------------------------------------------------------------------------

64106-- Clean

65107

66−idrisClean _ flags _ _ = do

67− cleanStdLib

68− cleanLLVM

108+idrisClean _ flags _ _ = cleanStdLib

69109 where

70110 verbosity = S.fromFlag $ S.cleanVerbosity flags

71111

72− cleanStdLib = do

73− makeClean "libs"

74−

75− cleanLLVM = makeClean "llvm"

112+ cleanStdLib = makeClean "libs"

76113

77114 makeClean dir = make verbosity [ "-C", dir, "clean", "IDRIS=idris" ]

78115

79−

80116-- -----------------------------------------------------------------------------

81117-- Configure

82118

83−idrisConfigure _ flags _ local = do

84− configureRTS

85− where

119+gitHash :: IO String

120+gitHash = do h <- Control.Exception.catch (readProcess "git" ["rev-parse", "--short", "HEAD"] "")

121+ (\e -> let e' = (e :: SomeException) in return "PRE")

122+ return $ takeWhile (/= '\n') h

123+

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

135+

136+-- Put the Git hash into a module for use in the program

137+-- For release builds, just put the empty string in the module

138+generateVersionModule verbosity dir release = do

139+ hash <- gitHash

140+ let versionModulePath = dir </> "Version_idris" Px.<.> "hs"

141+ putStrLn $ "Generating " ++ versionModulePath ++

142+ if release then " for release" else " for prerelease " ++ hash

143+ createDirectoryIfMissingVerbose verbosity True dir

144+ rewriteFileEx verbosity versionModulePath (versionModuleContents hash)

145+

146+ where versionModuleContents h = "module Version_idris where\n\n" ++

147+ "gitHash :: String\n" ++

148+ if release

149+ then "gitHash = \"\"\n"

150+ else "gitHash = \"git:" ++ h ++ "\"\n"

151+

152+-- Generate a module that contains the lib path for a freestanding Idris

153+generateTargetModule verbosity dir targetDir = do

154+ let absPath = isAbsolute targetDir

155+ let targetModulePath = dir </> "Target_idris" Px.<.> "hs"

156+ putStrLn $ "Generating " ++ targetModulePath

157+ createDirectoryIfMissingVerbose verbosity True dir

158+ rewriteFileEx verbosity targetModulePath (versionModuleContents absPath targetDir)

159+ where versionModuleContents absolute td = "module Target_idris where\n\n" ++

160+ "import System.FilePath\n" ++

161+ "import System.Environment\n" ++

162+ "getDataDir :: IO String\n" ++

163+ if absolute

164+ then "getDataDir = return \"" ++ td ++ "\"\n"

165+ else "getDataDir = do \n" ++

166+ " expath <- getExecutablePath\n" ++

167+ " execDir <- return $ dropFileName expath\n" ++

168+ " return $ execDir ++ \"" ++ td ++ "\"\n"

169+ ++ "getDataFileName :: FilePath -> IO FilePath\n"

170+ ++ "getDataFileName name = do\n"

171+ ++ " dir <- getDataDir\n"

172+ ++ " return (dir ++ \"/\" ++ name)"

173+

174+-- a module that has info about existence and location of a bundled toolchain

175+generateToolchainModule verbosity srcDir toolDir = do

176+ let commonContent = "module Tools_idris where\n\n"

177+ let toolContent = case toolDir of

178+ Just dir -> "hasBundledToolchain = True\n" ++

179+ "getToolchainDir = \"" ++ dir ++ "\"\n"

180+ Nothing -> "hasBundledToolchain = False\n" ++

181+ "getToolchainDir = \"\""

182+ let toolPath = srcDir </> "Tools_idris" Px.<.> "hs"

183+ createDirectoryIfMissingVerbose verbosity True srcDir

184+ rewriteFileEx verbosity toolPath (commonContent ++ toolContent)

185+

186+idrisConfigure _ flags pkgdesc local = do

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

192+ generateVersionModule verbosity libAutogenDir (isRelease (configFlags local))

193+ if isFreestanding $ configFlags local

194+ then do

195+ toolDir <- lookupEnv "IDRIS_TOOLCHAIN_DIR"

196+ generateToolchainModule verbosity libAutogenDir toolDir

197+ targetDir <- lookupEnv "IDRIS_LIB_DIR"

198+ case targetDir of

199+ Just d -> generateTargetModule verbosity libAutogenDir d

200+ Nothing -> error $ "Trying to build freestanding without a target directory."

201+ ++ " Set it by defining IDRIS_LIB_DIR."

202+ else

203+ generateToolchainModule verbosity libAutogenDir Nothing

204+ where

86205 verbosity = S.fromFlag $ S.configVerbosity flags

87206 version = pkgVersion . package $ localPkgDescr local

88207

@@ -92,13 +211,45 @@ idrisConfigure _ flags _ local = do

92211 -- the file after configure.

93212 configureRTS = make verbosity ["-C", "rts", "clean"]

94213

214+#if !(MIN_VERSION_Cabal(2,0,0))

215+ autogenComponentModulesDir lbi _ = autogenModulesDir lbi

216+#endif

217+

218+#if !(MIN_VERSION_Cabal(2,0,0))

219+rewriteFileEx :: Verbosity -> FilePath -> String -> IO ()

220+rewriteFileEx _ = rewriteFile

221+#endif

222+

95223-- -----------------------------------------------------------------------------

96224-- Build

97225

98−idrisBuild _ flags _ local = do

99− buildStdLib

100− buildRTS

101− when (usesLLVM $ configFlags local) buildLLVM

226+getVersion :: Args -> S.BuildFlags -> IO HookedBuildInfo

227+getVersion args flags = do

228+ hash <- gitHash

229+ let buildinfo = (emptyBuildInfo { cppOptions = ["-DVERSION="++hash] }) :: BuildInfo

230+ return (Just buildinfo, [])

231+

232+

233+#if !(MIN_VERSION_Cabal(2,0,0))

234+mkUnqualComponentName = id

235+#endif

236+

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"] })])

242+ where

243+ verbosity = S.fromFlag $ S.buildVerbosity flags

244+ dir = S.fromFlagOrDefault "dist" $ S.buildDistPref flags

245+#else

246+ return (Nothing, [])

247+#endif

248+

249+idrisBuild _ flags _ local

250+ = if (execOnly (configFlags local)) then buildRTS

251+ else do buildStdLib

252+ buildRTS

102253 where

103254 verbosity = S.fromFlag $ S.buildVerbosity flags

104255

@@ -108,49 +259,63 @@ idrisBuild _ flags _ local = do

108259 where

109260 makeBuild dir = make verbosity [ "-C", dir, "build" , "IDRIS=" ++ idrisCmd local]

110261

111− buildRTS = make verbosity (["-C", "rts", "build"] ++

262+ buildRTS = make verbosity (["-C", "rts", "build"] ++

112263 gmpflag (usesGMP (configFlags local)))

113264

114− buildLLVM = make verbosity ["-C", "llvm", "build"]

115−

116265 gmpflag False = []

117266 gmpflag True = ["GMP=-DIDRIS_GMP"]

118267

119268-- -----------------------------------------------------------------------------

120269-- Copy/Install

121270

122−idrisInstall verbosity copy pkg local = do

123− installStdLib

124− installRTS

125− when (usesLLVM $ configFlags local) installLLVM

271+idrisInstall verbosity copy pkg local

272+ = if (execOnly (configFlags local)) then installRTS

273+ else do installStdLib

274+ installRTS

275+ installManPage

126276 where

127277 target = datadir $ L.absoluteInstallDirs pkg local copy

128278

129279 installStdLib = do

130− putStrLn $ "Installing libraries in " ++ target

131− makeInstall "libs" target

280+ let target' = target -- </> "libs"

281+ putStrLn $ "Installing libraries in " ++ target'

282+ makeInstall "libs" target'

132283

133284 installRTS = do

134285 let target' = target </> "rts"

135286 putStrLn $ "Installing run time system in " ++ target'

136287 makeInstall "rts" target'

137288

138− installLLVM = do

139− let target' = target </> "llvm"

140− putStrLn $ "Installing LLVM library in " ++ target

141− makeInstall "llvm" target'

289+ installManPage = do

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")]

142293

143294 makeInstall src target =

144295 make verbosity [ "-C", src, "install" , "TARGET=" ++ target, "IDRIS=" ++ idrisCmd local]

145296

297+-- -----------------------------------------------------------------------------

298+-- Test

299+

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 }

305+

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

309+

146310-- -----------------------------------------------------------------------------

147311-- Main

148312

149313-- Install libraries during both copy and install

150−-- See http://hackage.haskell.org/trac/hackage/ticket/718

314+-- See https://github.com/haskell/cabal/issues/709

151315main = defaultMainWithHooks $ simpleUserHooks

152316 { postClean = idrisClean

153317 , postConf = idrisConfigure

318+ , preBuild = idrisPreBuild

154319 , postBuild = idrisBuild

155320 , postCopy = \_ flags pkg local ->

156321 idrisInstall (S.fromFlag $ S.copyVerbosity flags)

@@ -158,4 +323,5 @@ main = defaultMainWithHooks $ simpleUserHooks

158323 , postInst = \_ flags pkg local ->

159324 idrisInstall (S.fromFlag $ S.installVerbosity flags)

160325 NoCopyDest pkg local

326+ , testHook = idrisTestHook

161327 }

appveyor.ymlnew file+27

@@ -0,0 +1,27 @@

1+version: 1.0.{build}

2+init:

3+- ps: >-

4+ choco install cabal --no-progress

5+

6+ mkdir C:\ghc

7+

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"

9+

10+ 7z x C:\ghc\ghc.tar.xz -oC:\ghc

11+

12+ 7z x C:\ghc\ghc.tar -oC:\ghc

13+

14+ $env:PATH="$env:PATH;c:\ghc\ghc-8.8.2\bin;$HOME\AppData\Roaming\cabal\bin"

15+

16+ cabal v1-update

17+

18+ $env:current_posix=c:\msys64\usr\bin\cygpath -u $(pwd)

19+

20+environment:

21+ MSYSTEM: MINGW64

22+ MSYS2_PATH_TYPE: inherit

23+build_script:

24+- ps: >-

25+ c:\msys64\usr\bin\bash -l -c "cd $env:current_posix && cabal v1-install -fffi --enable-tests 2>&1"

26+test_script:

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 @@

1+# Starter pipeline

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:

4+# https://aka.ms/yaml

5+jobs:

6+ # Test a configuration with the oldest supported GHC

7+ - job: Linux_GHC_710

8+ pool:

9+ vmImage: 'Ubuntu 16.04'

10+ steps:

11+ - script: |

12+ sudo add-apt-repository ppa:hvr/ghc

13+ sudo apt-get update

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'

18+ - script: |

19+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH

20+ cabal update

21+ CABALFLAGS="-fffi -fci" make

22+ displayName: 'Build Idris'

23+ - script: |

24+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH

25+ make test_c

26+ displayName: 'Run tests'

27+ # Test on Linux

28+ - job: Linux

29+ pool:

30+ vmImage: 'Ubuntu 16.04'

31+ steps:

32+ - script: |

33+ sudo add-apt-repository ppa:hvr/ghc

34+ sudo apt-get update

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'

39+ - script: |

40+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH

41+ cabal update

42+ CABALFLAGS="-fffi -fci" make

43+ displayName: 'Build Idris'

44+ - script: |

45+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH

46+ make test_c

47+ displayName: 'Run tests'

48+ # Test on MacOS

49+ - job: macOS

50+ pool:

51+ vmImage: 'xcode9-macos10.13'

52+ steps:

53+ - script: |

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

57+ cabal update

58+ CABALFLAGS="-fffi -fci" make

59+ make test_c

60+ displayName: 'Build idris and run tests'

61+ # Test on Windows

62+ - job: Windows

63+ pool:

64+ vmImage: 'vs2017-win2016'

65+ steps:

66+ - powershell: |

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/"

70+ mkdir C:\ghc

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"

75+ - powershell: |

76+ cabal update

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"

83+ env:

84+ MSYSTEM: MINGW64

85+ MSYS2_PATH_TYPE: inherit

86+ displayName: "Build and test Idris"

87+ # Check styling

88+ - job: Stylize

89+ pool:

90+ vmImage: 'Ubuntu 16.04'

91+ steps:

92+ - script: |

93+ sudo add-apt-repository ppa:hvr/ghc

94+ sudo apt-get update

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'

99+ - script: |

100+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH

101+ cabal update

102+ cabal install stylish-haskell

103+ ./stylize.sh

104+ displayName: 'Run stylish'

105+ # Run tests on the node backend

106+ - job: JS

107+ pool:

108+ vmImage: 'Ubuntu 16.04'

109+ steps:

110+ - script: |

111+ sudo add-apt-repository ppa:hvr/ghc

112+ sudo apt-get update

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'

117+ - script: |

118+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH

119+ cabal update

120+ CABALFLAGS="-fffi -fci" make

121+ displayName: 'Build Idris'

122+ - script: |

123+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH

124+ make test_js

125+ displayName: 'Run tests'

126+ # Build docs

127+ - job: Docs

128+ pool:

129+ vmImage: 'Ubuntu 16.04'

130+ steps:

131+ - script: |

132+ sudo add-apt-repository ppa:hvr/ghc

133+ sudo apt-get update

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'

138+ - script: |

139+ export PATH=/opt/ghc/bin:$HOME/.cabal/bin:$PATH

140+ cabal update

141+ CABALFLAGS="-fffi -fci" make

142+ make lib_doc doc

143+ displayName: 'Build Docs'

benchmarks/ALL+2

@@ -1,2 +1,4 @@

11trivial/sortvec 2000

22quasigroups/qgsolve board

3+fasta/fasta 1

4+pidigits/pidigits 3000

benchmarks/build.pl+3−2

@@ -2,13 +2,14 @@

22

33$bmarks = `cat ALL`;

44@bm = split(/\n/, $bmarks);

5+$idris = $ENV{'IDRIS'} || "idris";

56

67foreach $b (@bm) {

78 if ($b =~ /([a-zA-Z0-9]+)\/([a-zA-Z0-9]+)\s+(.*)/) {

89 print "Building $1 / $2\n";

910 chdir $1;

10− system("idris --clean $2.ipkg");

11− system("idris --build $2.ipkg");

11+ system("$idris --clean $2.ipkg");

12+ system("$idris --build $2.ipkg") == 0 or die "Unable to build $2: $?";

1213 chdir "..";

1314 }

1415}

benchmarks/fasta/fasta.idrnew file+88

@@ -0,0 +1,88 @@

1+module Main

2+

3+import System

4+

5+alu : String

6+alu = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG"

7+ ++ "TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG"

8+ ++ "CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC"

9+ ++ "GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"

10+

11+{- The following string literal syntax doesn't work anymore. Until fixed we shall concat the strings.

12+alu = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGG\

13+ \TCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGG\

14+ \CGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGC\

15+ \GGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"

16+

17+-}

18+

19+

20+iub : List (Char, Double)

21+iub = [('a',0.27),('c',0.12),('g',0.12),('t',0.27),('B',0.02)

22+ ,('D',0.02),('H',0.02),('K',0.02),('M',0.02),('N',0.02)

23+ ,('R',0.02),('S',0.02),('V',0.02),('W',0.02),('Y',0.02)]

24+

25+homosapiens : List (Char, Double)

26+homosapiens = [('a',0.3029549426680),('c',0.1979883004921)

27+ ,('g',0.1975473066391),('t',0.3015094502008)]

28+

29+

30+takeRepeat : Int -> String -> String

31+takeRepeat n s = if n > m

32+ then s ++ takeRepeat (n-m) s

33+ else pack $ take (cast n) $ unpack s

34+ where

35+ m = cast $ length s

36+

37+splitAt' : Nat -> String -> (String, String)

38+splitAt' n s = let s' = unpack s in (pack $ take n s', pack $ drop n s')

39+

40+writeAlu : String -> String -> IO ()

41+writeAlu name s0 = putStrLn name *> go s0

42+ where

43+ go "" = pure ()

44+ go s = let (h,t) = splitAt' 60 s in putStrLn h *> go t

45+

46+replicate : Int -> Char -> String

47+replicate 0 c = ""

48+replicate n c = singleton c <+> replicate (n-1) c

49+

50+

51+accum : (Char,Double) -> (Char,Double) -> (Char,Double)

52+accum (_,p) (c,q) = (c,p+q)

53+

54+make : String -> Int -> List (Char, Double) -> Int -> IO Int

55+make name n0 tbl seed0 = do

56+ putStrLn name

57+ make' n0 0 seed0 ""

58+ where

59+ modulus : Int

60+ modulus = 139968

61+

62+ fill : List (Char,Double) -> Int -> List String

63+ fill ((c,p) :: cps) j =

64+ let k = min modulus (cast (cast modulus * p + 1))

65+ in replicate (k - j) c :: fill cps k

66+ fill _ _ = []

67+

68+ lookupTable : String

69+ lookupTable = Foldable.concat (fill (scanl accum ('a',0) tbl) 0)

70+

71+ make' : Int -> Int -> Int -> String -> IO Int

72+ make' 0 col seed buf = when (col > 0) (putStrLn buf) *> pure seed

73+ make' n col seed buf = do

74+ let newseed = modInt (seed * 3877 + 29573) modulus

75+ let nextchar = strIndex lookupTable newseed

76+ let newbuf = buf <+> singleton nextchar

77+ if col+1 >= 60

78+ then putStrLn newbuf *> make' (n-1) 0 newseed ""

79+ else make' (n-1) (col+1) newseed newbuf

80+

81+

82+main : IO ()

83+main = do

84+ (_ :: n :: _) <- getArgs

85+ writeAlu ">ONE Homo sapiens alu" (takeRepeat (fromInteger (cast n)*2) alu)

86+ nseed <- make ">TWO IUB ambiguity codes" (fromInteger (cast n)*3) iub 42

87+ make ">THREE Homo sapiens frequency" (fromInteger (cast n)*5) homosapiens nseed

88+ pure ()

benchmarks/fasta/fasta.ipkgnew file+6

@@ -0,0 +1,6 @@

1+package fasta

2+

3+modules = fasta

4+

5+executable = fasta

6+main = fasta

benchmarks/pidigits/pidigits.idrnew file+52

@@ -0,0 +1,52 @@

1+import System

2+import Data.Vect

3+

4+{- Toy program that outputs the n first digits of Pi.

5+

6+ Inspired from https://www.haskell.org/haskellwiki/Shootout/Pidigits.

7+ The original ns and str lazy lists have been replaced by strict functions.

8+

9+ Memory usage seems to be excessive. One of the branches of str is tail recursive, and

10+ the other one only needs to cons an extra Integer.

11+

12+ For reference, the Haskell version runs in 0m0.230s when printing to /dev/null.

13+ It almost runs in constant space.

14+-}

15+

16+data F = MkF Integer Integer Integer

17+

18+-- Prints the list of digits by groups of 10

19+loop : Nat -> Nat -> List Integer -> IO()

20+loop n k' Nil = putStrLn $ (pack $ Vect.replicate n ' ') ++ "\t:" ++ show k'

21+loop Z k' xs = do putStrLn ("\t:"++show k')

22+ loop 10 k' xs

23+loop (S k) k' (x::xs) = do putStr (show x)

24+ loop k (S k') xs

25+

26+fn : Integer -> F

27+fn k = MkF k (4*k+2) (2*k+1)

28+

29+flr : Integer -> F -> Integer

30+flr x (MkF q r t) = (q*x + r) `div` t

31+

32+comp : F -> F -> F

33+comp (MkF q r t) (MkF u v x) = MkF (q*u) (q*v+r*x) (t*x)

34+

35+-- Returns the list of digits of pi. Memory hungry.

36+str : F -> Integer -> Nat -> List Integer

37+str _ _ Z = Nil

38+str z k (S n) = if(y == flr 4 z)

39+ then y :: str (comp (MkF 10 (-10*y) 1) z ) k n

40+ else str (comp z (fn k)) (k+1) (S n)

41+ where y = flr 3 z

42+

43+pidigit : IO()

44+pidigit = do

45+ [_,a] <- getArgs

46+ let n = fromIntegerNat (the Integer (cast a))

47+ let l = str (MkF 1 0 1) 1 n

48+ loop 10 0 l

49+ pure ()

50+

51+main : IO ()

52+main = pidigit

benchmarks/pidigits/pidigits.ipkgnew file+6

@@ -0,0 +1,6 @@

1+package pidigits

2+

3+modules = pidigits

4+

5+executable = pidigits

6+main = pidigits

benchmarks/quasigroups/Main.idr+14−11

@@ -10,15 +10,18 @@ main = do

1010 case args of

1111 [_, path] => do

1212 f <- readFile path

13− case parse f of

14− Left err => putStrLn err

15− Right (_ ** (board ** legal)) => do

16− putStrLn "Got board:"

17− print board

18− putStrLn "Solving..."

19− case fillBoard board legal of

20− Nothing => putStrLn "No solution found"

21− Just (solved ** _) => do

22− putStrLn "Solution found:"

23− print solved

13+ case f of

14+ Left _err => putStrLn $ "Error reading file: " ++ path

15+ Right f' =>

16+ case parse f' of

17+ Left err => putStrLn err

18+ Right (_ ** (board ** legal)) => do

19+ putStrLn "Got board:"

20+ printLn board

21+ putStrLn "Solving..."

22+ case fillBoard board legal of

23+ Nothing => putStrLn "No solution found"

24+ Just (solved ** _) => do

25+ putStrLn "Solution found:"

26+ printLn solved

2427 [self] => putStrLn ("Usage: " ++ self ++ " <board file>")

benchmarks/quasigroups/Parser.idr+18−15

@@ -1,9 +1,12 @@

11module Parser

22

33import Decidable.Equality

4+import Data.Vect

45

56import Solver

67

8+%access public export

9+

710ParseErr : Type

811ParseErr = String

912

@@ -11,24 +14,24 @@ Parser : Nat -> Type

1114Parser n = Either ParseErr (b : Board n ** LegalBoard b)

1215

1316mapM : Monad m => (a -> m b) -> Vect n a -> m (Vect n b)

14−mapM _ Nil = return Vect.Nil

17+mapM _ Nil = pure Vect.Nil

1518mapM f (x::xs) = do

1619 x' <- f x

1720 xs' <- mapM f xs

18− return (Vect.(::) x' xs')

21+ pure (Vect.(::) x' xs')

1922

2023parseToken : String -> Either String (Cell n)

21−parseToken "." = return Nothing

24+parseToken "." = pure Nothing

2225parseToken "0" = Left "Got cell 0, expected 1-based numbering"

2326parseToken x = map Just (tryParseFin ((cast x) - 1))

2427 where

2528 tryParseFin : Int -> Either String (Fin n)

2629 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

2831 tryParseFin {n=S k} x =

2932 case tryParseFin {n=k} (x-1) of

3033 Left err => Left err

31− Right fin => return (fS fin)

34+ Right fin => pure (FS fin)

3235

3336length : Vect n a -> Nat

3437length {n=n} _ = n

@@ -42,16 +45,16 @@ parseCols {n=S k} row l cs = helper last l

4245 let here = (x, row) -- TODO: Determine why naming this makes idris smarter

4346 tok <- parseToken {n=S k} (index x cs)

4447 case tok of

45− Nothing => return (_ ** l)

48+ Nothing => pure (_ ** l)

4649 Just t =>

4750 case legalVal b here t of

4851 Yes prf => Right (_ ** Step prf l)

4952 No _ => Left ("Illegal cell " ++ index x cs)

5053

5154 helper : {b : Board (S k)} -> Fin (S k) -> LegalBoard b -> Parser (S k)

52− helper fZ l = step l fZ

53− helper (fS k) l = do

54− (_ ** next) <- step l (fS k)

55+ helper FZ l = step l FZ

56+ helper (FS k) l = do

57+ (_ ** next) <- step l (FS k)

5558 helper (weaken k) next

5659

5760parseRows : (b : Board n) -> LegalBoard b -> Vect n String -> Parser n

@@ -61,14 +64,14 @@ parseRows {n=S k} _ l rs = helper last l

6164 step : {b : Board (S k)} -> Fin (S k) -> LegalBoard b -> Parser (S k)

6265 step i l =

6366 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

6568 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)

6770

6871 helper : {b : Board (S k)} -> Fin (S k) -> LegalBoard b -> Parser (S k)

69− helper fZ l = step fZ l

70− helper (fS k) l = do

71− (_ ** next) <- step (fS k) l

72+ helper FZ l = step FZ l

73+ helper (FS k) l = do

74+ (_ ** next) <- step (FS k) l

7275 helper (weaken k) next

7376

7477parse : String -> Either String (n : Nat ** (b : Board n ** LegalBoard b))

@@ -76,4 +79,4 @@ parse str =

7679 let rows = fromList (lines str) in

7780 case parseRows {n=length rows} emptyBoard Base rows of

7881 Left msg => Left msg

79− Right board => return (_ ** board)

82+ Right board => pure (_ ** board)

benchmarks/quasigroups/Solver.idr+22−22

@@ -2,9 +2,11 @@ module Solver

22

33import Decidable.Equality

44import Control.Monad.State

5+import Data.Vect

56import Data.Vect.Quantifiers

67

78%default total

9+%access public export

810

911Cell : Nat -> Type

1012Cell n = Maybe (Fin n)

@@ -31,12 +33,12 @@ unlines (l::ls) = pack (foldl addLine (unpack l) (map unpack ls))

3133 addLine : List Char -> List Char -> List Char

3234 addLine w s = w ++ ('\n' :: s)

3335

34−instance Show (Board n) where

36+Show (Board n) where

3537 show (MkBoard rs) = unlines (map showRow rs)

3638

3739updateAt : Fin n -> Vect n a -> (a -> a) -> Vect n a

38−updateAt fZ (x::xs) f = f x :: xs

39−updateAt (fS i) (x::xs) f = x :: updateAt i xs f

40+updateAt FZ (x::xs) f = f x :: xs

41+updateAt (FS i) (x::xs) f = x :: updateAt i xs f

4042

4143setCell : Board n -> (Fin n, Fin n) -> Fin n -> Board n

4244setCell (MkBoard b) (x, y) value = MkBoard (updateAt y b (\row => updateAt x row (const (Just value))))

@@ -80,7 +82,7 @@ Empty : Cell n -> Type

8082Empty {n=n} x = (the (Cell n) Nothing) = x

8183

8284empty : (cell : Cell n) -> Dec (Empty cell)

83−empty Nothing = Yes refl

85+empty Nothing = Yes Refl

8486empty (Just _) = No nothingNotJust

8587

8688-- Predicate for legal cell assignments

@@ -95,7 +97,7 @@ legalVal b (x, y) v =

9597 case colSafe b x v of

9698 No prf' => No (\(_, cf, _) => prf' cf)

9799 Yes prf' =>

98− case empty (getCell b (x, y)) of

100+ case Solver.empty (getCell b (x, y)) of

99101 No prf'' => No (\(ef, _, _) => prf'' ef)

100102 Yes prf'' => Yes (prf'', prf', prf)

101103

@@ -103,11 +105,11 @@ legalVal b (x, y) v =

103105Filled : Cell n -> Type

104106--Filled {n=n} x = Not (Empty x) -- TODO: Find out why this doesn't work

105107Filled {n=n} = (\x => Not (Empty x))

106−--Filled {n=n} x = the (Maybe (Fin n)) Nothing = x -> _|_

107−--Filled {n=n} = \x => the (Maybe (Fin n)) Nothing = x -> _|_

108+--Filled {n=n} x = the (Maybe (Fin n)) Nothing = x -> Void

109+--Filled {n=n} = \x => the (Maybe (Fin n)) Nothing = x -> Void

108110

109111filled : (cell : Cell n) -> Dec (Filled cell)

110−filled Nothing = No (\f => f refl)

112+filled Nothing = No (\f => f Refl)

111113filled (Just _) = Yes nothingNotJust

112114

113115FullBoard : Board n -> Type

@@ -127,18 +129,18 @@ data LegalBoard : Board n -> Type where

127129CompleteBoard : Board n -> Type

128130CompleteBoard b = (LegalBoard b, FullBoard b)

129131

130−indexStep : {i : Fin n} -> {xs : Vect n a} -> {x : a} -> index i xs = index (fS i) (x::xs)

131−indexStep = refl

132+indexStep : {i : Fin n} -> {xs : Vect n a} -> {x : a} -> index i xs = index (FS i) (x::xs)

133+indexStep = Refl

132134

133135find : {P : a -> Type} -> ((x : a) -> Dec (P x)) -> (xs : Vect n a)

134136 -> Either (All (\x => Not (P x)) xs) (y : a ** (P y, (i : Fin n ** y = index i xs)))

135137find _ Nil = Left Nil

136138find d (x::xs) with (d x)

137− | Yes prf = Right (x ** (prf, (fZ ** refl)))

139+ | Yes prf = Right (x ** (prf, (FZ ** Refl)))

138140 | No prf =

139141 case find d xs of

140142 Right (y ** (prf', (i ** prf''))) =>

141− Right (y ** (prf', (fS i ** replace {P=(\x => y = x)} (indexStep {x=x}) prf'')))

143+ Right (y ** (prf', (FS i ** replace {P=(\x => y = x)} (indexStep {x=x}) prf'')))

142144 Left prf' => Left (prf::prf')

143145

144146findEmptyInRow : (xs : Vect n (Cell n)) -> Either (All Filled xs) (i : Fin n ** Empty (index i xs))

@@ -158,11 +160,11 @@ emptyCell (MkBoard rs) =

158160 helper Nil = Left Nil

159161 helper (r::rs) =

160162 case findEmptyInRow r of

161− Right (ci ** pf) => Right (fZ ** (ci ** pf))

163+ Right (ci ** pf) => Right (FZ ** (ci ** pf))

162164 Left prf =>

163165 case helper rs of

164166 Left prf' => Left (prf::prf')

165− Right (ri ** (ci ** pf)) => Right (fS ri ** (ci ** pf))

167+ Right (ri ** (ci ** pf)) => Right (FS ri ** (ci ** pf))

166168

167169

168170tryValue : {b : Board (S n)} -> LegalBoard b -> (c : (Fin (S n), Fin (S n))) -> Empty (getCell b c) -> (v : Fin (S n))

@@ -182,23 +184,21 @@ fillBoard {n=(S n)} b l with (emptyCell b)

182184 | Left full = Just (b ** (l, full))

183185 | Right (coords ** p) = recurse last

184186 where

185− %assert_total

186187 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))) $

188189 case tryValue l coords p v of

189190 Right success => (v, Just success)

190191 Left _ => -- TODO: Prove unsolvable

191192 case v of

192− fS k => tryAll (weaken k)

193− fZ => (v, Nothing)

193+ FS k => tryAll (weaken k)

194+ FZ => (v, Nothing)

194195

195− %assert_total

196196 recurse : Fin (S n) -> Maybe (b' : Board (S n) ** CompleteBoard b')

197− recurse start =

197+ recurse start = assert_total $

198198 case tryAll start of

199199 (_, Nothing) => Nothing

200− (fZ, Just (b' ** l')) => fillBoard b' l'

201− (fS next, Just (b' ** l')) =>

200+ (FZ, Just (b' ** l')) => fillBoard b' l'

201+ (FS next, Just (b' ** l')) =>

202202 case fillBoard b' l' of

203203 Just solution => Just solution

204204 Nothing => recurse (weaken next)

benchmarks/trivial/sortvec.idr+7−7

@@ -1,7 +1,9 @@

11module Main

22

33import System

4+import Effects

45import Effect.Random

6+import Data.Vect

57

68total

79insert : Ord a => a -> Vect n a -> Vect (S n) a

@@ -12,14 +14,12 @@ vsort : Ord a => Vect n a -> Vect n a

1214vsort [] = []

1315vsort (x :: xs) = insert x (vsort xs)

1416

15−mkSortVec : (n : Nat) -> Eff m [RND] (Vect n Int)

16−mkSortVec Z = return []

17−mkSortVec (S k) = return (fromInteger !(rndInt 0 10000) :: !(mkSortVec k))

17+mkSortVec : (n : Nat) -> Eff (Vect n Int) [RND]

18+mkSortVec Z = pure []

19+mkSortVec (S k) = pure (fromInteger !(rndInt 0 10000) :: !(mkSortVec k))

1820

1921main : IO ()

2022main = do (_ :: arg :: _) <- getArgs

21−-- let arg = "2000"

22− let vec = runPure [123456789] (mkSortVec (fromInteger (cast arg)))

23+ let vec = runPure $ (srand 123456789 *> mkSortVec (fromInteger (cast arg)))

2324 putStrLn "Made vector"

24− print (vsort vec)

25−

25+ printLn (vsort vec)

codegen/idris-codegen-c/Main.hsnew file+49

@@ -0,0 +1,49 @@

1+module Main where

2+

3+import Idris.AbsSyntax

4+import Idris.ElabDecls

5+import Idris.Main

6+import Idris.Options

7+import IRTS.CodegenC

8+import IRTS.Compiler

9+

10+import Util.System

11+

12+import Control.Monad

13+import System.Environment

14+import System.Exit

15+

16+

17+

18+data Opts = Opts { inputs :: [FilePath],

19+ interface :: Bool,

20+ output :: FilePath }

21+

22+showUsage = do putStrLn "A code generator which is intended to be called by the compiler, not by a user."

23+ putStrLn "Usage: idris-codegen-c <ibc-files> [-o <output-file>]"

24+ exitWith ExitSuccess

25+

26+getOpts :: IO Opts

27+getOpts = do xs <- getArgs

28+ return $ process (Opts [] False "a.out") xs

29+ where

30+ process opts ("-o":o:xs) = process (opts { output = o }) xs

31+ process opts ("--interface":xs) = process (opts { interface = True }) xs

32+ process opts (x:xs) = process (opts { inputs = x:inputs opts }) xs

33+ process opts [] = opts

34+

35+c_main :: Opts -> Idris ()

36+c_main opts = do runIO setupBundledCC

37+ elabPrims

38+ loadInputs (inputs opts) Nothing

39+ mainProg <- if interface opts

40+ then liftM Just elabMain

41+ else return Nothing

42+ ir <- compile (Via IBCFormat "c") (output opts) mainProg

43+ runIO $ codegenC ir

44+

45+main :: IO ()

46+main = do opts <- getOpts

47+ if (null (inputs opts))

48+ then showUsage

49+ else runMain (c_main opts)

codegen/idris-codegen-javascript/Main.hsnew file+42

@@ -0,0 +1,42 @@

1+module Main where

2+

3+import Idris.AbsSyntax

4+import Idris.ElabDecls

5+import Idris.Main

6+import Idris.Options

7+import IRTS.CodegenJavaScript

8+import IRTS.Compiler

9+

10+import System.Environment

11+import System.Exit

12+

13+

14+data Opts = Opts {

15+ inputs :: [FilePath]

16+ , output :: FilePath

17+ }

18+

19+showUsage = do putStrLn "A code generator which is intended to be called by the compiler, not by a user."

20+ putStrLn "Usage: idris-codegen-javascript <ibc-files> [-o <output-file>]"

21+ exitWith ExitSuccess

22+

23+getOpts :: IO Opts

24+getOpts = do xs <- getArgs

25+ return $ process (Opts [] "main.js") xs

26+ where

27+ process opts ("-o":o:xs) = process (opts { output = o }) xs

28+ process opts (x:xs) = process (opts { inputs = x:inputs opts }) xs

29+ process opts [] = opts

30+

31+jsMain :: Opts -> Idris ()

32+jsMain opts = do elabPrims

33+ loadInputs (inputs opts) Nothing

34+ mainProg <- elabMain

35+ ir <- compile (Via IBCFormat "javascript") (output opts) (Just mainProg)

36+ runIO $ codegenJavaScript ir

37+

38+main :: IO ()

39+main = do opts <- getOpts

40+ if (null (inputs opts))

41+ then showUsage

42+ else runMain (jsMain opts)

codegen/idris-codegen-node/Main.hsnew file+48

@@ -0,0 +1,48 @@

1+module Main where

2+

3+import Idris.AbsSyntax

4+import Idris.ElabDecls

5+import Idris.Main

6+import Idris.Options

7+import IRTS.CodegenJavaScript

8+import IRTS.Compiler

9+

10+import Paths_idris

11+

12+import Control.Monad

13+

14+import System.Environment

15+import System.Exit

16+

17+data Opts = Opts { inputs :: [FilePath]

18+ , interface :: Bool

19+ , output :: FilePath

20+ }

21+

22+showUsage = do putStrLn "A code generator which is intended to be called by the compiler, not by a user."

23+ putStrLn "Usage: idris-codegen-node <ibc-files> [-o <output-file>]"

24+ exitWith ExitSuccess

25+

26+getOpts :: IO Opts

27+getOpts = do xs <- getArgs

28+ return $ process (Opts [] False "main.js") xs

29+ where

30+ process opts ("-o":o:xs) = process (opts { output = o }) xs

31+ process opts ("--interface":xs) = process (opts { interface = True }) xs

32+ process opts (x:xs) = process (opts { inputs = x:inputs opts }) xs

33+ process opts [] = opts

34+

35+jsMain :: Opts -> Idris ()

36+jsMain opts = do elabPrims

37+ loadInputs (inputs opts) Nothing

38+ mainProg <- if interface opts

39+ then return Nothing

40+ else liftM Just elabMain

41+ ir <- compile (Via IBCFormat "node") (output opts) mainProg

42+ runIO $ codegenNode ir

43+

44+main :: IO ()

45+main = do opts <- getOpts

46+ if (null (inputs opts))

47+ then showUsage

48+ else runMain (jsMain opts)

config.mk+26−14

@@ -1,9 +1,26 @@

1−CC :=cc

1+UNAME_INFO := $(shell uname -a)

2+

3+ifeq ($(filter , $(findstring MSYS, $(UNAME_INFO)) $(findstring MINGW, $(UNAME_INFO))),)

4+ ifeq (cc,$(CC))

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.

8+ CC =gcc

9+ endif

10+endif

11+

12+RANLIB ?=ranlib

13+

214CABAL :=cabal

3−CFLAGS :=-O2 -Wall $(CFLAGS)

4−#CABALFLAGS :=

15+# IDRIS_ENABLE_STATS should not be set in final release

16+# Any flags defined here which alter the RTS API must also be added to src/IRTS/CodegenC.hs

17+CFLAGS :=-O2 -Wall -std=c99 -pipe -fdata-sections -ffunction-sections -D_POSIX_C_SOURCE=200809L -DHAS_PTHREAD -DIDRIS_ENABLE_STATS $(CFLAGS)

18+

19+# CABALFLAGS :=

20+CABALFLAGS += --enable-tests

521## Disable building of Effects

6−#CABALFLAGS :=-f NoEffects

22+#CABALFLAGS :=-f NoEffects $(CABALFLAGS)

23+

724

825ifneq (, $(findstring bsd, $(MACHINE)))

926 GMP_INCLUDE_DIR :=

@@ -14,25 +31,20 @@ endif

1431MACHINE := $(shell $(CC) -dumpmachine)

1532ifneq (, $(findstring darwin, $(MACHINE)))

1633 OS :=darwin

17−else

18−ifneq (, $(findstring cygwin, $(MACHINE)))

34+else ifneq (, $(findstring cygwin, $(MACHINE)))

1935 OS :=windows

20−else

21−ifneq (, $(findstring mingw, $(MACHINE)))

36+else ifneq (, $(findstring mingw, $(MACHINE)))

37+ OS :=windows

38+else ifneq (, $(findstring windows, $(MACHINE)))

2239 OS :=windows

2340else

2441 OS :=unix

2542endif

26−endif

27−endif

2843

2944ifeq ($(OS),darwin)

3045 SHLIB_SUFFIX :=.dylib

31−else

32−ifeq ($(OS),windows)

46+else ifeq ($(OS),windows)

3347 SHLIB_SUFFIX :=.DLL

3448else

3549 SHLIB_SUFFIX :=.so

3650endif

37−endif

38−

contribs/gtksourceview-2.0-language-spec/idris.langdeleted−254

@@ -1,254 +0,0 @@

1−<?xml version="1.0" encoding="UTF-8"?>

2−<!--

3−

4− Author: Dominic Mulligan

5− Copyright (C) 2012 Dominic Mulligan <dominic.p.mulligan@gmail.com>

6−

7− Lexemes taken from src/Idris/Parser.hs.

8−

9− Based on the gtksourceview-2.0 Haskell style by:

10−

11− Authors: Duncan Coutts, Anders Carlsson

12− Copyright (C) 2004, 2007 Duncan Coutts <duncan@haskell.org>

13− Copyright (C) 2004 Anders Carlsson <andersca@gnome.org>

14−

15− This library is free software; you can redistribute it and/or

16− modify it under the terms of the GNU Library General Public

17− License as published by the Free Software Foundation; either

18− version 2 of the License, or (at your option) any later version.

19−

20− This library is distributed in the hope that it will be useful,

21− but WITHOUT ANY WARRANTY; without even the implied warranty of

22− MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

23− Library General Public License for more details.

24−

25− You should have received a copy of the GNU Library General Public

26− License along with this library; if not, write to the

27− Free Software Foundation, Inc., 59 Temple Place - Suite 330,

28− Boston, MA 02111-1307, USA.

29−

30−-->

31−<language id="idris" _name="Idris" version="2.0" _section="Sources">

32− <metadata>

33− <property name="mimetypes">text/x-idris</property>

34− <property name="globs">*.idr</property>

35− </metadata>

36−

37− <styles>

38− <style id="preprocessor" _name="Preprocessor" map-to="def:preprocessor"/>

39− <style id="comment" _name="Comment" map-to="def:comment"/>

40− <style id="variable" _name="Variable" />

41− <style id="symbol" _name="Symbol" />

42− <style id="keyword" _name="Keyword" map-to="def:keyword"/>

43− <style id="tactic" _name="Tactic" map-to="def:keyword"/>

44− <style id="type" _name="Data Type" map-to="def:type"/>

45− <style id="string" _name="String" map-to="def:string"/>

46− <style id="character" _name="Character" map-to="def:character"/>

47− <style id="char-escape" _name="Escaped Character" map-to="def:special-char"/>

48− <style id="decimal" _name="Decimal" map-to="def:decimal"/>

49− <style id="float" _name="Float" map-to="def:floating-point"/>

50− </styles>

51−

52− <definitions>

53− <define-regex id="symbolchar">[!#$%&amp;*+./&gt;=&lt;?@:\\^|~-]</define-regex>

54−

55− <context id="line-comment" style-ref="comment" end-at-line-end="true" class="comment" class-disabled="no-spell-check">

56− <start>(?&lt;!\%{symbolchar})--+(?!\%{symbolchar})</start>

57− <include>

58− <context ref="def:in-comment"/>

59− <context ref="haddock:line-paragraph"/>

60− <context ref="haddock:directive"/>

61− </include>

62− </context>

63−

64− <context id="block-comment" style-ref="comment" class="comment" class-disabled="no-spell-check">

65− <start>\{-</start>

66− <end>-\}</end>

67− <include>

68− <context ref="def:in-comment"/>

69− <context ref="haddock:block-paragraph"/>

70− <context ref="haddock:directive"/>

71− <context ref="block-comment"/>

72− </include>

73− </context>

74−

75− <context id="variable" style-ref="variable">

76− <match>\b[a-z_][0-9a-zA-Z_'#]*</match>

77− </context>

78−

79− <context id="type-or-constructor" style-ref="type">

80− <match>\b[A-Z][0-9a-zA-Z._'#]*</match>

81− </context>

82−

83− <context id="symbol" style-ref="symbol" extend-parent="false">

84− <match>\%{symbolchar}+</match>

85− </context>

86−

87− <context id="keysymbol" style-ref="keyword">

88− <prefix>(?&lt;!\%{symbolchar})</prefix>

89− <suffix>(?!\%{symbolchar})</suffix>

90− <keyword>\.</keyword>

91− <keyword>:</keyword>

92− <keyword>%</keyword>

93− <keyword>=</keyword>

94− <keyword>\|</keyword>

95− <keyword>\</keyword>

96− <keyword>-&gt;</keyword>

97− <keyword>@</keyword>

98− <keyword>~</keyword>

99− <keyword>=&gt;</keyword>

100− <keyword>\(\)</keyword>

101− <keyword>\_\|\_</keyword>

102− <keyword>\*\*</keyword>

103− </context>

104−

105− <define-regex id="escaped-character" extended="true">

106− \\( # leading backslash

107− [abfnrtv\\"\'&amp;] | # escaped character

108− [0-9]+ | # decimal digits

109− o[0-7]+ | # 'o' followed by octal digits

110− x[0-9A-Fa-f]+ | # 'x' followed by hex digits

111− \^[A-Z@\[\\\]^_] | # control character codes

112− NUL | SOH | STX | ETX | EOT | ENQ | ACK |

113− BEL | BS | HT | LF | VT | FF | CR | SO |

114− SI | DLE | DC1 | DC2 | DC3 | DC4 | NAK |

115− SYN | ETB | CAN | EM | SUB | ESC | FS | GS |

116− RS | US | SP | DEL # control char names

117− )

118− </define-regex>

119−

120− <context id="string" style-ref="string" end-at-line-end="true" class="string" class-disabled="no-spell-check">

121− <start>"</start>

122− <end>"</end>

123− <include>

124− <context ref="def:line-continue"/>

125− <context style-ref="char-escape">

126− <match>\%{escaped-character}</match>

127− </context>

128− </include>

129− </context>

130−

131− <context id="char" style-ref="character" end-at-line-end="true">

132− <start>'</start>

133− <end>'</end>

134− <include>

135− <context style-ref="char-escape" once-only="true">

136− <match>\%{escaped-character}</match>

137− </context>

138− <context once-only="true" extend-parent="false">

139− <match>.</match>

140− </context>

141− <context style-ref="def:error" extend-parent="false">

142− <match>.</match>

143− </context>

144− </include>

145− </context>

146−

147− <context id="float" style-ref="float">

148− <match extended="true">

149− [0-9]+ \. [0-9]+ ([eE][+-]?[0-9]+)?

150− | [0-9]+ [eE][+-]?[0-9]+

151− </match>

152− </context>

153−

154− <context id="decimal" style-ref="decimal">

155− <match>[0-9]+</match>

156− </context>

157−

158− <context id="keyword" style-ref="keyword">

159− <keyword>Set</keyword>

160− <keyword>case</keyword>

161− <keyword>class</keyword>

162− <keyword>data</keyword>

163− <keyword>default</keyword>

164− <keyword>do</keyword>

165− <keyword>record</keyword>

166− <keyword>foreign</keyword>

167− <keyword>lib</keyword>

168− <keyword>link</keyword>

169− <keyword>include</keyword>

170− <keyword>hide</keyword>

171− <keyword>freeze</keyword>

172− <keyword>access</keyword>

173− <keyword>logging</keyword>

174− <keyword>abstract</keyword>

175− <keyword>public</keyword>

176− <keyword>private</keyword>

177− <keyword>namespace</keyword>

178− <keyword>syntax</keyword>

179− <keyword>term</keyword>

180− <keyword>pattern</keyword>

181− <keyword>params</keyword>

182− <keyword>import</keyword>

183− <keyword>using</keyword>

184− <keyword>in</keyword>

185− <keyword>infix</keyword>

186− <keyword>infixl</keyword>

187− <keyword>infixr</keyword>

188− <keyword>prefix</keyword>

189− <keyword>instance</keyword>

190− <keyword>let</keyword>

191− <keyword>module</keyword>

192− <keyword>of</keyword>

193− <keyword>if</keyword>

194− <keyword>else</keyword>

195− <keyword>then</keyword>

196− <keyword>where</keyword>

197− <keyword>with</keyword>

198− <keyword>type</keyword>

199− <keyword>proof</keyword>

200− <keyword>tactics</keyword>

201− <keyword>static</keyword>

202− <keyword>impossible</keyword>

203− <keyword>total</keyword>

204− <keyword>assert_total</keyword>

205− </context>

206−

207− <context id="tactic" style-ref="tactic">

208− <keyword>rewrite</keyword>

209− <keyword>exact</keyword>

210− <keyword>intros</keyword>

211− <keyword>intro</keyword>

212− <keyword>refine</keyword>

213− <keyword>trivial</keyword>

214− <keyword>focus</keyword>

215− <keyword>try</keyword>

216− <keyword>compute</keyword>

217− <keyword>solve</keyword>

218− <keyword>attack</keyword>

219− <keyword>refl</keyword>

220− <keyword>state</keyword>

221− <keyword>term</keyword>

222− <keyword>undo</keyword>

223− <keyword>qed</keyword>

224− <keyword>abandon</keyword>

225− </context>

226−

227− <context id="body">

228− <include>

229− <context ref="line-comment"/>

230− <context ref="block-comment"/>

231− <context ref="keyword"/>

232− <context ref="tactic" />

233− <context ref="variable"/>

234− <context ref="type-or-constructor"/>

235− <context ref="keysymbol"/>

236− <context ref="symbol"/>

237− <context ref="string"/>

238− <context ref="char"/>

239− <context ref="float"/>

240− <context ref="decimal"/>

241− </include>

242− </context>

243−

244− <context id="idris" class="no-spell-check">

245− <include>

246− <context ref="c:if0-comment"/>

247− <context ref="c:include"/>

248− <context ref="c:preprocessor"/>

249− <context ref="body"/>

250− </include>

251− </context>

252−

253− </definitions>

254−</language>

contribs/idriscasesplit.vimdeleted−100

@@ -1,100 +0,0 @@

1−function IdrisReload()

2− let file = expand("%")

3− let tc = system("idris --client :l " . file)

4− if (! (tc is ""))

5− echo tc

6− endif

7− return tc

8−endfunction

9−

10−function IdrisShowType()

11− w

12− let word = expand("<cword>")

13− let tc = IdrisReload()

14− if (! (tc is ""))

15− echo tc

16− else

17− let ty = system("idris --client :t " . word)

18− echo ty

19− endif

20− return tc

21−endfunction

22−

23−function IdrisCaseSplit()

24− let view = winsaveview()

25− w

26− let cline = line(".")

27− let word = expand("<cword>")

28− let tc = IdrisReload()

29−

30− if (tc is "")

31− let fn = "idris --client :cs! " . cline . " " . word

32− let result = system(fn)

33− if (! (result is ""))

34− echo result

35− else

36− e

37− call winrestview(view)

38− endif

39− endif

40−endfunction

41−

42−function IdrisMakeWith()

43− let view = winsaveview()

44− w

45− let cline = line(".")

46− let word = expand("<cword>")

47− let tc = IdrisReload()

48−

49− if (tc is "")

50− let fn = "idris --client :mw! " . cline . " " . word

51− let result = system(fn)

52− if (! (result is ""))

53− echo result

54− else

55− e

56− call winrestview(view)

57− call search("_")

58− endif

59− endif

60−endfunction

61−

62−function IdrisAddClause()

63− let view = winsaveview()

64− w

65− let cline = line(".")

66− let word = expand("<cword>")

67− let tc = IdrisReload()

68−

69− if (tc is "")

70− let fn = "idris --client :ac! " . cline . " " . word

71− let result = system(fn)

72− if (! (result is ""))

73− echo result

74− else

75− e

76− call winrestview(view)

77− call search(word)

78−

79− endif

80− endif

81−endfunction

82−

83−function IdrisEval()

84− let tc = IdrisReload()

85− if (tc is "")

86− let expr = input ("Expression: ")

87− let fn = "idris --client '" . expr . "'"

88− let result = system(fn)

89− echo result

90− endif

91− echo ""

92−endfunction

93−

94−map <LocalLeader>t :call IdrisShowType()<ENTER>

95−map <LocalLeader>r :call IdrisReload()<ENTER>

96−map <LocalLeader>c :call IdrisCaseSplit()<ENTER>

97−map <LocalLeader>d ?:<ENTER>b:call IdrisAddClause()<ENTER>w

98−map <LocalLeader>w 0:call IdrisMakeWith()<ENTER>

99−map <LocalLeader>e :call IdrisEval()<ENTER>

100−

contribs/idrislang.stydeleted−190

@@ -1,190 +0,0 @@

1−%% --------------------------------------------------- [ Idris Styling Package ]

2−%%

3−%% A set of LaTeX macros and styling for working with Idris in LaTeX

4−%%

5−%% + Provides a listings bindings:

6−%% + idris :: default ascii

7−%% + literateidris :: convert ascii maths to math symbols.

8−%% + Defines a `numbers' and `default' listings style.

9−%% + Defines a `code' environment for typesetting idris.

10−%% + \begin{code}[...] ... \end{code}

11−%% + Defines commands typesetting the name Idris.

12−%% + \Idris{}

13−%% + \idris{}

14−%%

15−%% Options:

16−%% - literate :: turn on literate idris for code environments.

17−%% - numbers :: turn on numbers for code environments.

18−%%

19−%% ----------------------------------------------------------- [ Begin Package ]

20−\ProvidesPackage{idrislang}

21−

22−\RequirePackage{ifthen}

23−\RequirePackage{listings}

24−\RequirePackage{xspace}

25−%% ----------------------------------------------------------------- [ Options ]

26−\newboolean{literate}

27−\setboolean{literate}{false}

28−\newboolean{numbers}

29−\setboolean{numbers}{false}

30−

31−\DeclareOption{literate}{%

32− \setboolean{literate}{true}

33−}

34−

35−\DeclareOption{numbers}{%

36− \setboolean{numbers}{true}

37−}

38−

39−\ProcessOptions\relax

40−

41−%% ---------------------------------------------------------------- [ Commands ]

42−\newcommand{\Idris}{\textsc{Idris}\xspace}

43−\newcommand{\idris}{\textsc{Idris}\xspace}

44−

45−%% --------------------------------------------------- [ Define Idris Listings ]

46−\lstdefinelanguage{idris}{%

47− sensitive,%

48−%% ----------------------------------------------------------- [ Default Style ]

49− basicstyle=\ttfamily,

50− flexiblecolumns=false,

51− commentstyle=\footnotesize\sffamily,

52−%% ---------------------------------------------------------------- [ Keywords ]

53−%% From Idris Parser and idris-mode and vimscript

54− keywords={%

55− abstract, attack, case, compute, do, dsl, else, exact, focus, if,

56− import, in, infix, infixl, infixr, instance, intros, module,

57− mutual, namespace, of, let, parameters, partial, pattern, prefix,

58− private, public, refine, rewrite, solve, syntax, term, then,

59− total, trivial, try, using, where, with

60−},

61−%% ------------------------------------------------------- [ Prelude Functions ]

62−%% Generated using

63−%% find lib/ -name "*.idr" | xargs grep -e "^[a-zA-Z0-9]* :" | awk -F : '{printf $2", "}'

64− morekeywords={%

65− class, data, instance, record, dsl, postulate, default, assert_total,

66− lambda, variable, index_first, index_next

67− % trace, unsafePerformPrimIO, FInt, FChar, FByte, FShort, FLong,

68− % FBits8, FBits16, FBits32, FBits64, FBits8x16, FBits16x8,

69− % FBits32x4, FBits64x2, interpFTy, ForeignTy, mkForeignPrim,

70− % mkLazyForeignPrim, liftPrimIO, fork, unsafePerformIO, listens,

71− % censor, Writer, liftReaderT, asks, Reader, modify, gets, State,

72− % RWS, nGTSm, decideNatLTE, lte, vectInjective1, vectInjective2,

73− % run, myID, send, msgWaiting, recv, recvWithSender, create,

74− % sendToThread, checkMsgs, getMsg, viewB8x16, viewB16x8, viewB32x4,

75− % viewB64x2, pow, exp, log, pi, sin, cos, tan, asin, acos, atan,

76− % atan2, sinh, cosh, tanh, sqrt, floor, ceiling, count, countFrom,

77− % curry, uncurry, uniformB8x16, uniformB16x8, uniformB32x4,

78− % uniformB64x2, putStr, putStrLn, print, getLine, putChar, getChar,

79− % fopen, openFile, closeFile, fread, fwrite, feof, ferror, nullPtr,

80− % nullStr, validFile, while, readFile, userSuppliedName, seq, try,

81− % mkPair, getUName, unApply, mkApp, binderTy, divCeil, nextPow2,

82− % nextBytes, machineTy, bitsUsed, natToBits, getPad, pad8, pad16,

83− % pad32, pad64, shiftLeft, shiftRightLogical, shiftRightArithmetic,

84− % and, or, xor, plus, minus, times, sdiv, udiv, srem, urem, lt, lte,

85− % eq, gte, gt, complement, zeroExtend, intToBits, bitsToInt, bitAt,

86− % getBit, setBit, unsetBit, bitsToStr, findElem, replaceElem,

87− % replaceByElem, mapElem, anyNilAbsurd, anyElim, any, negAnyAll,

88− % notAllHere, notAllThere, all, length, index, weaken, take, toList,

89− % fromList, replicate, foldl, foldr, map, pad, zeroBoundIsEmpty,

90− % empty, insert, delete, contains, fromList, toList, applyKleisli,

91− % applyMor, applyEndo, absZ, negZ, negNat, minusNatZ, plusZ, subZ,

92− % multZ, fromInt, natPlusZPlus, natMultZMult, doubleNegElim,

93− % posInjective, negSInjective, posNotNeg, plusZeroLeftNeutralZ,

94− % plusZeroRightNeutralZ, plusCommutativeZ, modBin, modComp, div,

95− % rem, intToMod, modToStr, branch4, branch5, branch6, branch7,

96− % merge1, merge2, merge3, treeLookup, treeInsert, delType,

97− % treeDelete, treeToList, empty, lookup, insert, delete, fromList,

98− % toList, getWitness, getProof, FalseElim, replace, sym, trans,

99− % lazy, par, malloc, Not, id, the, const, fst, snd, flip, cong,

100− % boolElim, not, intToBool, boolOp, div, mod, strHead, strTail,

101− % strCons, strIndex, reverse, null, getArgs, getEnv, setEnv,

102− % unsetEnv, getEnvironment, exit, usleep, sequence, toHexDigit,

103− % b8ToString, b16ToString, b32ToString, b64ToString, tail, head,

104− % last, init, index, deleteAt, replaceAt, take, drop, fromList,

105− % replicate, zipWith, zip, unzip, concat, elemBy, elem, lookupBy,

106− % lookup, hasAnyBy, hasAny, find, findIndex, elemIndexBy, elemIndex,

107− % nubBy, nub, isPrefixOfBy, isPrefixOf, isSuffixOfBy, isSuffixOf,

108− % catMaybes, diag, range, isLeft, isRight, choose, either, lefts,

109− % rights, partitionEithers, fromEither, maybeToEither, strM, unpack,

110− % pack, span, break, split, ltrim, trim, words, lines, foldr1,

111− % unwords, length, realPart, imagPart, mkPolar, cis, magnitude,

112− % phase, conjugate, isNothing, isJust, maybe, fromMaybe, toMaybe,

113− % justInjective, lowerMaybe, raiseToMaybe, isNil, isCons, head,

114− % tail, last, init, take, drop, takeWhile, dropWhile, list, length,

115− % repeat, replicate, zipWith, zipWith3, zip, zip3, unzip, unzip3,

116− % mapMaybe, toList, reverse, intersperse, intercalate, elemBy, elem,

117− % lookupBy, lookup, hasAnyBy, hasAny, find, findIndex, findIndices,

118− % elemIndexBy, elemIndex, elemIndicesBy, elemIndices, filter, nubBy,

119− % nub, span, break, split, partition, isPrefixOfBy, isPrefixOf,

120− % isSuffixOfBy, isSuffixOf, sorted, mergeBy, merge, sort,

121− % maybeToList, listToMaybe, catMaybes, appendNilRightNeutral,

122− % appendAssociative, lengthAppend, mapPreservesLength,

123− % mapDistributesOverAppend, mapFusion, hasAnyByNilFalse,

124− % hasAnyNilFalse, fromIntegerNat, toIntegerNat, hyper, log2, gcd,

125− % liftA, liftA2, liftA3, guard, when, finToNat, finToInt, weaken,

126− % strengthen, last, natToFin, integerToFin, fromInteger, flatten,

127− % return, isUpper, isLower, isAlpha, isDigit, isAlphaNum, isSpace,

128− % isNL, toUpper, toLower, isHexDigit, isValidHeap, merge, insert,

129− % findMinimum, deleteMinimum, toList, fromList, sort, main, foldl,

130− % concat, concatMap, and, or, any, all, sum, product, Vars,

131− % getAction, setInfo, getInfo, lift, output, queryVars, postVars,

132− % cookieVars, queryVar, getOutput, getHeaders, flushHeaders, flush,

133− % getVars, getContent, getCgiEnv, runCGI, mult

134− },

135−%% ---------------------------------------------------------------- [ Comments ]

136− morecomment=[l]--,%

137− morecomment=[n]{\{-}{-\}}

138−}[keywords,comments,strings]%

139−

140−%% ---------------------------------------- [ Define Idris with Literate Stuff ]

141−\lstdefinelanguage{literateidris}[]{idris}{

142− literate= {+}{{$+$}}1

143− {/}{{$/$}}1

144− {*}{{$*$}}1

145− {=}{{$=$}}1

146− {>}{{$>$}}1

147− {<}{{$<$}}1

148− {\\}{{$\lambda$}}1

149− {\\\\}{{\char`\\\char`\\}}1

150− {->}{{$\rightarrow$}}2

151− {>=}{{$\geq$}}2

152− {<-}{{$\leftarrow$}}2

153− {<=}{{$\leq$}}2

154− {=>}{{$\Rightarrow$}}2

155− {==}{{$\equiv$}}2

156− {\ .}{{$\circ$}}2

157− {\ .\ }{{$\circ$}}2

158− {>>}{{>>}}2

159− {>>=}{{>>=}}2

160− {|}{{$\mid$}}1,

161−}

162−%% -------------------------------------------------- [ Default Listings Style ]

163−

164−\lstdefinestyle{default}{%

165− xleftmargin=\parindent,

166− tabsize=2

167−}

168−\lstdefinestyle{numbers}{%

169− xleftmargin=\parindent,

170− tabsize=2,

171− numbers=left,

172− numbersep=10pt,

173− numberstyle=\footnotesize\sffamily,

174− frame=leftline

175−}

176−

177−%% ------------------------------------------------------ [ A Code Environment ]

178−%% Replicate the existence of literate haskell code environments,

179−%% option to make pretty with numbers.

180−\lstnewenvironment{code}[1][]

181− {\ifthenelse{\boolean{literate}}{%

182− \lstset{language=literateidris}}{%

183− \lstset{language=idris}}

184− \ifthenelse{\boolean{numbers}}{%

185− \lstset{style=numbers, #1}}{%

186− \lstset{style=default, #1}}

187− }

188− {}

189−\endinput

190−%% --------------------------------------------------------------------- [ EOF ]

contribs/lib/SQLite3/Makefiledeleted−16

@@ -1,16 +0,0 @@

1−# This makefile compiles the project

2−#

3−

4−.PHONY: all

5−

6−sqltest : testunit.idr Sqlite3.idr sqlite3api.o

7− idris testunit.idr -o sqltest

8−

9−sqlite3api.o : sqlite3api.c

10− gcc -c sqlite3api.c

11−

12−sqlite3api.so: sqlite3api.c

13− gcc -fPIC -o sqlite3api.so -shared sqlite3api.c

14−

15−all : sqltest sqlite3api.o

16−

contribs/lib/SQLite3/Sqlexpr.idrdeleted−278

@@ -1,278 +0,0 @@

1−module Sqlexpr

2−import Prelude.List

3−

4−-----------------------------------------------------------------------------

5−-- |

6−-- Module : sqlexpr

7−-- Copyright : (c) The University of St Andrews, 2012

8−--

9−-- Implementations for SQLite query data type.

10−--

11−-----------------------------------------------------------------------------

12−

13−

14−-----------------------------------------------------------

15−-- | SQL data type

16−-----------------------------------------------------------

17−

18−data Value = VInt Int

19− | VStr String

20− | VFloat Float

21− | VCol String

22− | VNULL

23−

24−--Perhaps could extend this by adding

25−-- a dot operator to allow mapping

26−-- between table and column and

27−-- comparing different table columns.

28−

29−data Cond = Equals Value Value

30− | MkGT Value Value

31− | MkGTE Value Value

32− | MkLT Value Value

33− | MkLTE Value Value

34− | MkNULL Value

35−

36−data SelVar = Cols (List String)

37− | ALL

38−

39−data ColType = CInt String -- parsed as string "int"

40− | Varchar String

41−

42−

43−

44−mutual

45− data Clause = MkCond Cond

46− | AND Clause Clause

47− | OR Clause Clause

48− | Empty

49− | MkSQL SQL

50−

51− data condClause = SET Clause

52− | WHERE condClause Clause

53−

54− data Constr = NOTNULL

55− | UNIQUE Constr

56− | None

57− | PRIMARYKEY

58− | FOREIGNKEY

59− | CHECK

60− | DEFAULT

61−

62−

63− data SQL = SELECT SelVar SQL Clause

64− | TBL (List String)

65− | INSERT SQL (List Value)

66− | INSERTC SQL (List Value) (List Value)

67− | UPDATE SQL condClause

68− | CREATE SQL (List (Value, ColType , Constr))

69−

70−-- remember to remove these funcs later

71−-- foldr1 : (a -> a -> a) -> List a -> a

72−-- foldr1 f [x] = x

73−-- foldr1 f (x::xs) = f x (foldr1 f xs)

74−

75−

76−-- unwords' : List (List Char) -> List Char

77−-- unwords' [] = []

78−-- unwords' ws = (foldr1 addSpace ws)

79−-- where

80−-- addSpace : List Char -> List Char -> List Char

81−-- addSpace w s = w ++ (' ' :: s)

82−--

83−--

84−-- unwords : List String -> String

85−-- unwords = pack . unwords' . map unpack

86−

87−-----------------------------------------------------------

88−-- | This function replaces values with question mark

89−-- following by an index number. It then puts the value

90−-- replaced, in the list.

91−-----------------------------------------------------------

92−

93−valString : List (Maybe (Int, Value)) -> Value -> (String, List (Maybe (Int, Value)))

94−valString xs (VInt x) = ("?" ++ show (cast (length xs) + 1), xs ++ [Just (cast ((length xs) + 1), (VInt x))])

95−valString xs (VStr x) = ("?" ++ show (cast (length xs) + 1), xs ++ [Just (cast ((length xs) + 1), (VStr x))])

96−valString xs (VFloat x) = ("?" ++ show (cast (length xs) + 1), xs ++ [Just (cast ((length xs) + 1), (VFloat x))])

97−valString xs (VCol n) = (n, xs)

98−

99−-----------------------------------------------------------

100−-- | This function calls valString on a list of Values

101−-- and separates the values by commas.

102−-----------------------------------------------------------

103−

104−listVal : List (Maybe (Int, Value)) -> List Value -> (String, List (Maybe (Int, Value)))

105−listVal xs [] = ("", xs)

106−listVal xs (v::vs) = let (str, newxs) = (valString xs v) in

107− let (str', newxs') = listVal newxs vs in

108− (unwords (intersperse "," (words (str) ++ words (str'))), newxs')

109−

110−-----------------------------------------------------------

111−-- | Parses the type of column to be created.

112−-----------------------------------------------------------

113−

114−getColType : List (Maybe (Int, Value)) -> ColType -> (String, List (Maybe (Int, Value)))

115−getColType xs (CInt x) = ("int", xs)

116−getColType xs (Varchar str) = ("varchar(255)", xs)

117−

118−-----------------------------------------------------------

119−-- | CREATE Constraints

120−-----------------------------------------------------------

121−

122−getConstr : List (Maybe (Int, Value)) -> Constr -> (String, List (Maybe (Int, Value)))

123−getConstr xs (NOTNULL) = ("NOT NULL", xs)

124−getConstr xs (UNIQUE constr) = ("NOT NULL UNIQUE", xs)

125−getConstr xs (PRIMARYKEY) = ("PRIMARY KEY", xs)

126−getConstr xs (FOREIGNKEY) = ("FOREIGN KEY", xs)

127−getConstr xs (CHECK) = ("CHECK", xs)

128−getConstr xs (DEFAULT) = ("DEFAULT", xs)

129−getConstr xs (None) = ("", xs)

130−

131−putBrackets : String -> String

132−putBrackets str = "(" ++ str ++ ")"

133−

134−-----------------------------------------------------------

135−-- | Used to detect a complex type in a nested SQLite query

136−-- This function is used for bracketing the nested queries.

137−-----------------------------------------------------------

138−complexType : SQL -> Bool

139−complexType (TBL tbl) = False

140−complexType (SELECT vars sql c) = True

141−

142−-----------------------------------------------------------

143−-- | Used in CREATE

144−-----------------------------------------------------------

145−

146−listValType : List (Maybe (Int, Value)) -> List (Value, ColType , Constr) -> (String, List (Maybe (Int, Value)))

147−listValType xs [] = ("", xs)

148−listValType xs ((val, types, constr) :: vs) =

149− let (str , newxs) = valString xs val in

150− let (str' , newxs') = getColType newxs types in

151− let (str'', newxs'') = getConstr newxs' constr in

152− let (finalstr, finalxs) = listValType newxs'' vs in

153− (unwords (intersperse " " (words str ++ words str' ++ words str'' ++ words finalstr)) , finalxs)

154−

155−

156−-----------------------------------------------------------

157−-- | Evaluates a conditional WHERE clause

158−-----------------------------------------------------------

159−

160−evalCond : List (Maybe (Int, Value)) -> Cond -> (String, List (Maybe (Int, Value)))

161−evalCond xs (Equals val1 val2) = let (restring , newxs ) = valString xs val1 in

162− let (restring2, newxs') = valString newxs val2 in

163− (restring ++ " = " ++ restring2, newxs')

164−

165−evalCond xs (MkGT val1 val2) = let (restring , newxs ) = valString xs val1 in

166− let (restring2, newxs') = valString newxs val2 in

167− (restring ++ " > " ++ restring2, newxs')

168−

169−evalCond xs (MkGTE val1 val2) = let (restring , newxs ) = valString xs val1 in

170− let (restring2, newxs') = valString newxs val2 in

171− (restring ++ " >= " ++ restring2, newxs')

172−

173−evalCond xs (MkLT val1 val2) = let (restring , newxs ) = valString xs val1 in

174− let (restring2, newxs') = valString newxs val2 in

175− (restring ++ " < " ++ restring2, newxs')

176−

177−evalCond xs (MkLTE val1 val2) = let (restring , newxs ) = valString xs val1 in

178− let (restring2, newxs') = valString newxs val2 in

179− (restring ++ " =< " ++ restring2, newxs')

180−

181−evalCond xs (MkNULL val) = let (restring , newxs ) = valString xs val in

182− (restring ++ " IS NULL " , newxs)

183−

184−

185−-----------------------------------------------------------

186−-- | Evaluates clauses

187−-- Supports WHERE Clause

188−-- WHERE Clause And Another-Clause

189−-- WHERE Clause Or Another-Clause

190−-----------------------------------------------------------

191−clauseString : List (Maybe (Int, Value)) -> Clause -> (String, List (Maybe (Int, Value)))

192−

193−clauseString xs (Empty) = ("" , []) -- No condition

194−clauseString xs (MkCond cond') = let (condstr, newxs) = evalCond xs cond' in

195− (condstr , newxs)

196−

197−clauseString xs (AND c1 c2) = let (clausestr, newxs) = clauseString xs c1 in

198− let (clausestr2, newxs') = clauseString newxs c2 in

199− (clausestr ++ " AND " ++ clausestr2 , newxs')

200−

201−clauseString xs (OR c1 c2) = let (clausestr, newxs) = clauseString xs c1 in

202− let (clausestr2, newxs') = clauseString newxs c2 in

203− (clausestr ++ " OR " ++ clausestr2 , newxs')

204−

205−

206−-----------------------------------------------------------

207−-- | Evaluates conditional clauses.

208−-----------------------------------------------------------

209−

210−condClauseStr : List (Maybe (Int, Value)) -> condClause -> (String, List (Maybe (Int, Value)))

211−condClauseStr xs (SET setcl) = let (condstr, newxs) = clauseString xs setcl in

212− (" SET " ++ condstr, newxs)

213−

214−condClauseStr xs (WHERE setcl1 setcl2) = let (condstr, newxs) = condClauseStr xs setcl1 in

215− let (condstr', newxs') = clauseString newxs setcl2 in

216− ( condstr ++ " WHERE " ++ condstr', newxs')

217−

218−

219−-----------------------------------------------------------

220−-- | Evaluates queries by calling the other functions

221−-- on each part of the query

222−-----------------------------------------------------------

223−evalSQL : List (Maybe (Int, Value)) -> SQL -> (String, List (Maybe (Int, Value)))

224−-- SELECT data from tbl1 where num > (SELECT num from tbl1 where num = 24)

225−-- evalSQL [] ((SELECT ALL)(TBL "tbl")(MkSQL ((SELECT ALL) (TBL "tbl")(MkCond (VCol "))))

226−-- NTBF

227−--clauseString xs (MkSQL sql) = (evalSQL xs sql)

228−

229−-- Separate list of tables

230−-- For complex type, return list returned by evalSQL

231−-- And add brackets

232−evalSQL xs (TBL tbl) = (unwords (intersperse "," ( tbl)), xs)

233−evalSQL xs (SELECT vars sql' c) =

234− let (sqlstring, newxs) = evalSQL xs sql' in

235− let (csstring, newxs') = clauseString newxs c in

236− case c of

237− Empty => case vars of

238− ALL => if complexType sql'

239− then ("SELECT " ++ "*" ++ " FROM " ++

240− putBrackets sqlstring ++ csstring, newxs)

241− else ("SELECT " ++ "*" ++ " FROM " ++ sqlstring ++

242− csstring, newxs')

243− Cols selvar => if complexType sql'

244− then ("SELECT " ++ unwords selvar ++

245− " FROM " ++ putBrackets sqlstring ++ csstring, newxs)

246− else ("SELECT " ++ unwords selvar ++ " FROM " ++ sqlstring ++

247− csstring, newxs')

248− _ => case vars of

249− ALL => if complexType sql'

250− then ("SELECT " ++ "*" ++ " FROM " ++

251− " WHERE " ++ csstring, newxs)

252− else ("SELECT " ++ "*" ++ " FROM " ++ sqlstring

253− ++ " WHERE " ++ csstring, newxs')

254− Cols selvar => if complexType sql'

255− then ("SELECT " ++ (unwords selvar) ++ " FROM " ++

256− putBrackets sqlstring ++ " WHERE " ++

257− csstring , newxs)

258− else ("SELECT " ++ (unwords selvar) ++ " FROM " ++ sqlstring ++

259− " WHERE " ++ csstring, newxs')

260−

261−

262−evalSQL xs (INSERT sql vals) = let (tblname, newvals) = evalSQL xs sql in

263− let (str, newxs ) = listVal newvals vals in

264− ("INSERT INTO " ++ tblname ++ " VALUES (" ++ str ++ ")", newxs)

265−

266−evalSQL xs (INSERTC sql cols vals) = let (tblname, newvals) = evalSQL xs sql in

267− let (strcol, newcol) = listVal newvals cols in

268− let (strval, newcolval) = listVal newcol vals in

269− ("INSERT INTO " ++ tblname ++ "(" ++ strcol ++ ")" ++ "VALUES (" ++ strval ++ ")", newcolval)

270−

271−

272−evalSQL xs (UPDATE sql cl) = let (tblname, newxs) = evalSQL xs sql in

273− let (csstring, newxs') = condClauseStr newxs cl in

274− ("UPDATE " ++ tblname ++ csstring, newxs')

275−

276−evalSQL xs (CREATE sql details) = let (sqlstring, newxs) = evalSQL xs sql in

277− let (csstring, newxs') = listValType newxs details in

278− ("CREATE TABLE " ++ sqlstring ++ "(" ++ csstring ++ ")", newxs')

contribs/lib/SQLite3/Sqlite3.idrdeleted−425

@@ -1,425 +0,0 @@

1−module Sqlite3

2−import Sqlexpr

3−

4−

5−%lib C "sqlite3"

6−%link C "sqlite3api.o"

7−%include C "sqlite3api.h"

8−

9−-----------------------------------------------------------------------------

10−-- |

11−-- Module : sqlite3

12−-- Copyright : (c) The University of St Andrews, 2012

13−--

14−-- Library built on top of FFI supporting basic SQLite C/C++ Interface

15−-- functions.

16−--

17−-----------------------------------------------------------------------------

18−

19−-- | The types supported by Idris returned by the database functions.

20−

21−data DBVal = DBInt Int

22− | DBText String

23− | DBFloat Float

24− | DBNull

25−

26−-- Database pointer

27−data DBPointer = MkDBPointer Ptr

28−-- Table pointer

29−data TBPointer = MkTBPointer Ptr

30−-- Statement pointer

31−data StmtPtr = MkStmtPtr Ptr

32−

33−Table : Type

34−Table = List (List DBVal)

35−

36−-- ForMap used in to_list_v1

37−forM : Applicative f => List a -> (a -> f b) -> f (List b)

38−forM xs f = (sequence (map f xs))

39−

40−-- Neater error handling done using DB

41−data DB a = MkDB (IO (Either String a))

42−

43−instance Functor DB where

44− map f (MkDB action) = MkDB (do res <- action

45− return (map f res))

46−

47−

48−instance Applicative DB where

49− pure = MkDB . return . Right

50− (MkDB f) <$> (MkDB x) = MkDB (do f' <- f

51− case f' of

52− Left err => return (Left err)

53− Right op => x >>= (return . map op))

54−

55−

56−instance Monad DB where

57− (MkDB l) >>= k = MkDB (do c <- l

58− case c of

59− Left err => return (Left err)

60− Right v => case k v of

61− MkDB k' => k')

62− return x = MkDB (return (Right x))

63−

64−fail : String -> DB a

65−fail err = MkDB (return (Left err))

66−

67−liftIO : IO a -> DB a

68−liftIO f = MkDB (do f' <- f

69− return (Right f'))

70−

71−ioError : String -> IO a

72−ioError err = do putStrLn err

73− return (believe_me ())

74−

75−runDB : DB a -> IO a

76−runDB (MkDB f) = do f' <- f

77− case f' of

78− Right v => return v

79− Left str => ioError str

80−

81−-----------------------------------------------------------------------------

82−-- | Opens an SQLite database file as specified by the String name argument.

83−-----------------------------------------------------------------------------

84−

85−open_db : String -> DB DBPointer

86−open_db name = do x <- liftIO (mkForeign (FFun "sqlite3_open_idr" [FString] FPtr) name)

87− return (MkDBPointer x)

88−

89−-----------------------------------------------------------------------------

90−-- | Destructor for the DBPointer.

91−-----------------------------------------------------------------------------

92−

93−close_db : DBPointer -> DB Int

94−close_db (MkDBPointer pointer) = liftIO (mkForeign (FFun "sqlite3_close_idr" [FPtr] FInt) pointer)

95−

96−-----------------------------------------------------------------------------

97−-- | Wrapper around prepare, step and finalize.

98−-----------------------------------------------------------------------------

99−

100−exec_db : DBPointer -> String -> DB Int

101−exec_db (MkDBPointer pointer) stmt = do

102− x <- liftIO (mkForeign (FFun "sqlite3_exec_idr" [FPtr, FString] FInt) pointer stmt)

103− if (x == 1)

104− then fail "Could not execute."

105− else return x

106−

107−-----------------------------------------------------------------------------

108−-- | Executes a prepared query. Use of this version is recommended.

109−-----------------------------------------------------------------------------

110−

111−exec_db_v2 : StmtPtr -> DB Int

112−exec_db_v2 (MkStmtPtr pointer) = do

113− x <- liftIO (mkForeign (FFun "exec_db" [FPtr] FInt) pointer)

114− if (x == 21)

115− then fail "No data returned."

116− else return x

117−

118−-----------------------------------------------------------------------------

119−-- | Returns the error stored in the buffer by exec_db function.

120−-- This function can only be used with exec_db and get_table.

121−-- Only these functions store any occured error in the buffer array.

122−-----------------------------------------------------------------------------

123−

124−get_error : DBPointer -> IO String

125−get_error (MkDBPointer pointer) = mkForeign (FFun "sqlite3_get_error" [FPtr] FString) pointer

126−

127−

128−-----------------------------------------------------------------------------

129−-- | Compiles the query inot a byte-code program in order to execute it.

130−-- Returns a pointer to a Statement pointer on a successful call.

131−-- Returns a null pointer on a failure.

132−-----------------------------------------------------------------------------

133−

134−prepare_db : DBPointer -> String -> DB StmtPtr

135−prepare_db (MkDBPointer pointer) cmd = do

136− result <- liftIO (mkForeign (FFun "sqlite3_prepare_idr" [FPtr, FString] FPtr) pointer cmd)

137− flag <- liftIO (nullPtr result)

138− if flag

139− then fail "Error occured while preparing"

140− else return (MkStmtPtr result)

141−

142−-----------------------------------------------------------------------------

143−-- | Returns the error stored in the buffer by exec_db function.

144−-- This function can only be used with exec_db and get_table.

145−-- Only these functions store any occured error in the buffer array.

146−-----------------------------------------------------------------------------

147−

148−step_db : StmtPtr -> DB Int

149−step_db (MkStmtPtr pointer)= do

150− x <- liftIO (mkForeign (FFun "sqlite3_step_idr" [FPtr] FInt)pointer)

151− if ( x == 101)

152− then fail "SQLITE_DONE"

153− else return x

154−

155−-----------------------------------------------------------------------------

156−-- | Deletes a prepared statement. This function must be called after

157−-- prepare function.

158−-----------------------------------------------------------------------------

159−

160−finalize_db : StmtPtr -> DB Int

161−finalize_db (MkStmtPtr pointer) = do

162− x <- liftIO (mkForeign (FFun "sqlite3_finalize_idr" [FPtr] FInt) pointer)

163− if (x /= 0)

164− then fail "Could not finalize"

165− else return x

166−

167−-----------------------------------------------------------------------------

168−-- | Resets a prepared statement pointer back to its initial state.

169−-----------------------------------------------------------------------------

170−

171−reset_db : StmtPtr -> DB Int

172−reset_db (MkStmtPtr pointer) = do

173− x <- liftIO (mkForeign (FFun "sqlite3_reset_idr" [FPtr] FInt) pointer)

174− if (x /= 0)

175− then fail "Could not reset"

176− else return x

177−

178−-----------------------------------------------------------------------------

179−-- | These routines obtain column information.

180−-----------------------------------------------------------------------------

181−

182−column_count : DBPointer -> IO (Either String Int)

183−column_count (MkDBPointer pointer) = do

184− x <- mkForeign (FFun "sqlite3_column_count_idr" [FPtr] FInt) pointer

185− return $ if (x == 0 )

186− then Left "No Data"

187− else (Right x)

188−

189−column_name : DBPointer -> Int -> IO String

190−column_name (MkDBPointer pointer) iCol =

191− mkForeign (FFun "sqlite3_column_name_idr" [FPtr, FInt] FString) pointer iCol

192−

193−column_decltype : DBPointer -> Int -> IO String

194−column_decltype (MkDBPointer pointer) iCol =

195− mkForeign (FFun "sqlite3_column_decltype_idr" [FPtr, FInt] FString) pointer iCol

196−

197−

198−column_bytes : DBPointer -> Int -> IO Int

199−column_bytes (MkDBPointer pointer) iCol =

200− mkForeign (FFun "sqlite3_column_bytes_idr" [FPtr, FInt] FInt) pointer iCol

201−

202−

203−column_blob : DBPointer -> Int -> IO String

204−column_blob (MkDBPointer pointer) iCol =

205− mkForeign (FFun "sqlite3_column_bytes_idr" [FPtr, FInt] FString) pointer iCol

206−

207−

208−column_text : DBPointer -> Int -> IO String

209−column_text (MkDBPointer pointer) iCol =

210− mkForeign (FFun "sqlite3_column_text_idr" [FPtr, FInt] FString) pointer iCol

211−

212−

213−column_Int : DBPointer -> Int -> IO Int

214−column_Int (MkDBPointer pointer) iCol =

215− mkForeign (FFun "sqlite3_column_int_idr" [FPtr, FInt] FInt) pointer iCol

216−

217−-----------------------------------------------------------------------------

218−-- | These routines support some of SQLite backup functions.

219−-----------------------------------------------------------------------------

220−

221−backup_init : DBPointer -> String -> DBPointer -> String -> IO DBPointer

222−backup_init (MkDBPointer des_pointer) destName (MkDBPointer src_pointer) srcName =

223− do x <- mkForeign (FFun "sqlite3_backup_init_idr" [FPtr,FString, FPtr, FString] FPtr)

224− des_pointer destName src_pointer srcName

225− return (MkDBPointer x)

226−

227−backup_step : DBPointer -> Int -> IO Int

228−backup_step (MkDBPointer pointer) nPage =

229− mkForeign (FFun "sqlite3_backup_step_idr" [FPtr, FInt] FInt) pointer nPage

230−

231−backup_finish : DBPointer -> IO Int

232−backup_finish (MkDBPointer pointer) =

233− mkForeign (FFun "sqlite3_backup_finish_idr" [FPtr] FInt) pointer

234−

235−backup_remaining : DBPointer -> IO Int

236−backup_remaining (MkDBPointer pointer) =

237− mkForeign (FFun "sqlite3_backup_remaining_idr" [FPtr] FInt) pointer

238−

239−

240−-----------------------------------------------------------------------------

241−-- | Use of this interface is not recommended.

242−-- This function returns a result table. The functions num_row and num_col

243−-- are used to obtain the number of rows and columns.

244−-- These functions can be used to print the resulting table.

245−-----------------------------------------------------------------------------

246−

247−get_table : DBPointer -> String -> DB TBPointer

248−get_table (MkDBPointer pointer) name = do

249− x <- liftIO(mkForeign (FFun "sqlite3_get_table_idr" [FPtr, FString] FPtr) pointer name)

250− flag <- liftIO (nullPtr x)

251− if flag

252− then do x <- liftIO(get_error_table pointer) ; fail x

253− else return (MkTBPointer x)

254− where

255− get_error_table : Ptr-> IO String

256− get_error_table pointer = do x <- mkForeign (FFun "sqlite3_get_error" [FPtr] FString) pointer

257− return x

258−

259−

260−free_table : TBPointer -> IO ()

261−free_table (MkTBPointer pointer) = do x <- mkForeign (FFun "sqlite3_free_table_idr" [FPtr] FUnit) pointer

262− return ()

263−

264−-----------------------------------------------------------------------------

265−-- | This version of these function obtain the row and column number

266−-- from the Table struct. These functions are only used with get_table.

267−-----------------------------------------------------------------------------

268−

269−num_row : TBPointer -> IO Int

270−num_row (MkTBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_row" [FPtr] FInt) pointer

271− return x

272−

273−num_col : TBPointer -> IO Int

274−num_col (MkTBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_col" [FPtr] FInt) pointer

275− return x

276−

277−-----------------------------------------------------------------------------

278−-- | This version of these function obtain the row and column number

279−-- from the Database struct.

280−-----------------------------------------------------------------------------

281−

282−num_row_v2 : DBPointer -> IO Int

283−num_row_v2 (MkDBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_row_v2" [FPtr] FInt) pointer

284− return x

285−

286−num_col_v2 : DBPointer -> IO Int

287−num_col_v2 (MkDBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_col_v2" [FPtr] FInt) pointer

288− return x

289−

290−-----------------------------------------------------------------------------

291−-- | This function prints the result of a query by checking the type

292−-- of each value returned, it then calls the appropriate function.

293−-- Ther result is one of the DBVal variants.

294−-----------------------------------------------------------------------------

295−

296−get_data : DBPointer -> Int -> Int -> IO DBVal

297−get_data (MkDBPointer pointer) row col = do

298− ty <- get_data_type pointer row col

299− helper ty

300− where get_data_type : Ptr ->Int -> Int -> IO Int

301− get_data_type pointer row col =

302− mkForeign (FFun "sqlite3_get_data_type" [FPtr, FInt, FInt] FInt) pointer row col

303− get_data_val_int : Ptr -> Int -> IO Int

304− get_data_val_int pointer col =

305− mkForeign (FFun "sqlite3_get_val_int" [FPtr,FInt] FInt) pointer col

306−

307− get_data_val_text : Ptr -> Int -> IO String

308− get_data_val_text pointer col =

309− mkForeign (FFun "sqlite3_get_val_text" [FPtr, FInt] FString) pointer col

310−

311− get_data_val_float : Ptr -> Int -> IO Float

312− get_data_val_float pointer col =

313− mkForeign (FFun "sqlite3_get_float" [FPtr, FInt] FFloat) pointer col

314−

315− helper : Int -> IO DBVal

316− helper 1 = do i <- get_data_val_int pointer col ; return (DBInt i)

317− helper 2 = do i <- get_data_val_float pointer col ; return (DBFloat i)

318− helper 3 = do i <- get_data_val_text pointer col; return (DBText i)

319− helper _ = return DBNull

320−

321−-----------------------------------------------------------------------------

322−-- | This function makes use of get_data to get all the result.

323−-----------------------------------------------------------------------------

324−

325−toList_v1 : DBPointer -> DB Table

326−toList_v1 db = do nbR <- liftIO (num_row_v2 db)

327− nmC <- liftIO (num_col_v2 db)

328− res <- liftIO $ forM [0..(nbR-1)] $ \ i =>

329− forM [0..(nmC-1)] $ \ j => get_data db i j

330− return (the (List (List DBVal)) res)

331−

332−strcat : String -> String-> String

333−strcat str1 str2 = str1 ++ str2

334−

335−-----------------------------------------------------------------------------

336−-- | This version of toList retunrs result from get_table

337−-- This could be removed if not needed in the future.

338−-----------------------------------------------------------------------------

339−

340−--toList_v2 : String -> String -> DBPointer -> DB Table

341−--toList_v2 name stmt x = do

342−-- ptr <- (get_table x (stmt))

343−-- nbR <- liftIO (num_row ptr)

344−-- nmC <- liftIO (num_col ptr)

345−-- res <- forM [0..(nbR-1)] (\ i =>

346−-- forM [0..(nmC-1)] (\ j =>

347−-- liftIO(get_data x name i j)

348−--

349−-- )

350−-- )

351−-- liftIO (free_table ptr)

352−-- return res

353−

354−

355−-----------------------------------------------------------------------------

356−-- | These routines support binding the types supported by Idris.

357−-- These return a pointer to statement pointer since we want to allow

358−-- binding multiple values by implementing a recursive function.

359−-----------------------------------------------------------------------------

360−

361−bind_int : StmtPtr -> Int -> Int -> DB StmtPtr

362−bind_int (MkStmtPtr pointer) indexval val = do

363− x <- liftIO (mkForeign (FFun "sqlite3_bind_int_idr" [FPtr, FInt, FInt] FPtr) pointer indexval val)

364− flag <- liftIO (nullPtr x)

365− if flag

366− then fail "Could not bind int."

367− else return (MkStmtPtr x)

368−

369−

370−bind_float : StmtPtr -> Int -> Float -> DB StmtPtr

371−bind_float (MkStmtPtr pointer) indexval val = do

372− x <- liftIO (mkForeign (FFun "sqlite3_bind_float_idr" [FPtr, FInt, FFloat] FPtr) pointer indexval val)

373− flag <- liftIO (nullPtr x)

374− if flag

375− then fail "Could not bind float."

376− else return (MkStmtPtr x)

377−

378−bind_text : StmtPtr -> String -> Int -> Int -> DB StmtPtr

379−bind_text (MkStmtPtr pointer) text indexval lengthval = do

380− x <- liftIO (mkForeign (FFun "sqlite3_bind_text_idr" [FPtr, FString, FInt, FInt] FPtr)

381− pointer text indexval lengthval)

382− flag <- liftIO(nullPtr x)

383− if flag

384− then fail "Could not bind text."

385− else return (MkStmtPtr x)

386−

387−bind_null : StmtPtr -> Int -> DB StmtPtr

388−bind_null (MkStmtPtr pointer) indexval = do

389− x <- liftIO (mkForeign (FFun "sqlite3_bind_null_idr" [FPtr, FInt] FPtr) pointer indexval)

390− flag <- liftIO (nullPtr x)

391− if flag

392− then fail "Could not bind null."

393− else return (MkStmtPtr x)

394−

395−-----------------------------------------------------------------------------

396−-- | String Length

397−-----------------------------------------------------------------------------

398−

399−strlen : String -> DB Int

400−strlen str = liftIO (mkForeign (FFun "strLength" [FString] FInt) str)

401−

402−instance Show DBVal where

403− show (DBInt i) = "Int val: " ++ show i ++ "\n"

404− show (DBText i) = "Text val: " ++ show i ++ "\n"

405− show (DBFloat i) = "Float val: " ++ show i ++ "\n"

406− show (DBNull ) = "NULL"

407−

408−-----------------------------------------------------------------------------

409−-- | Multi bind a list of values.

410−-----------------------------------------------------------------------------

411−

412−bindMulti : StmtPtr-> List (Maybe (Int, Value)) -> DB StmtPtr

413−bindMulti pointer [] = return pointer

414−bindMulti pointer (Nothing :: vs) = bindMulti pointer vs

415−bindMulti pointer ((Just (indexs, (VInt i)))::vs) =

416− do x <- bind_int pointer indexs i

417− bindMulti x vs

418−bindMulti pointer ((Just (indexs, (VStr s)))::vs) =

419− do len <- strlen s

420− x <- bind_text pointer s indexs len

421− bindMulti x vs

422−bindMulti pointer ((Just (indexs, (VFloat f)))::vs) =

423− do x <- bind_float pointer indexs f

424− bindMulti x vs

425−

contribs/lib/SQLite3/newdb.dbdeleted

Binary file not shown.

contribs/lib/SQLite3/somedb.dbdeleted

Binary file not shown.

contribs/lib/SQLite3/sqlite3.texdeleted−157

@@ -1,157 +0,0 @@

1− \documentclass[11pt]{article}

2− \topmargin -1.5cm

3− \oddsidemargin -0.04cm

4− \evensidemargin -0.04cm

5− \textwidth 16.59cm

6− \textheight 21.94cm

7− %\pagestyle{empty}

8− \parskip 7.2pt

9− \parindent 0pt

10−

11− \begin{document}

12− \section{Introduction}

13−\label{Introduction}

14−This document provides overview on how the Idris library for SQLite3 works. The code base is written on top of the

15−SQLite3 C/C++ Interface.

16−This library supports some features of the low-level library, implemented in a higher level basis.

17−The library allows making use of queries as data types. The aim of this library is to avoid

18−SQL injections which are the most common security issues.

19−To avoid this we have defined a datatype which describes queries.

20−The queries are written using these data types and parsed as quoted string

21−while replacing values with \emph{indexed question mark} to be binded with the prepared statement.

22−This prevents the user from preparing the queries inappropriately by not allowing to pass

23−any types of values directly to the prepare function. However this is a design choice, the library

24−does not prevent the user from passing a String directly to the prepare function.

25−

26−\section{Using the library}

27−\label{Using the library}

28−Simple examples have been provided in the \emph{testunit.idr} file.

29−To open a database, use the open\_db function which takes the filename as a string.

30−This function implements the sqlite3\_open function.

31−This function returns a pointer to the database which can be used by other function

32−to access the database object.

33−Whether or not an error occurs when it is opened,

34−resources should be released by passing it to close\_db when it is no longer required.

35−A query can then be builts using the supported data types.

36−The library supports limited number of queries at the moment. The supported sql commands are :

37−\newline

38−

39−\textbf{SELECT,}

40−\textbf{INSERT,}

41−\textbf{UPDATE,}

42−\textbf{CREATE}

43−

44−\subsection{Creating Queries}

45−\label{Creating Queries}

46−

47−To create a query, use the evalSQL function which takes an empty list and the SQL query.

48−The routine evaluates the expression recrusively by dividing it into smaller parts,

49−filling up the list with the received values. For instance the following is a valid query:

50−

51−let sql = evalSQL [ ] ((SELECT ALL)(TBL ["tbl1"]) (MkCond (MkNULL (VCol "data"))))

52−\newline

53−\newline{This will be parsed as :}

54−\b{“SELECT * FROM tbl1 WHERE data IS NULL “}

55−

56−The evaluator returns a string and a list of indexed values.

57−The string part of the query could be parsed to prepare.

58−\emph{evalSQL} parses the query as a string replacing values with \emph{?} and an index starting from one,

59−storing them in the list given to it as an argument.

60−For example:

61−

62−

63−evalSQL [ ] (SELECT (Cols ["data"]) (SELECT (Cols["num","data"]) (TBL ["tbl1"])

64−\newline (MkCond(Equals(VCol "num")(VInt 2))))Empty))

65−

66−is passed to prepare as :

67−

68−SELECT * FROM tbl1 WHERE data = ?1 AND num = ?2 OR num = ?3

69−

70−and returns the list as follows:

71−\newline{(Just (1, VStr "data0")) ,(Just (2, VInt 1)) , (Just (3, VInt 2))}

72−

73−The values in the list are binded to the statement using bindMulti function.

74−This function takes the statement pointer returned by prepare and the list returned by evalSQL

75−and binds the values by calling the appropriate functions.

76−

77−The function exec\_db\_v2 executes the statement.

78−Note that the other version of exec\_db implements the sqlite3\_exec() interface which is a wrapper

79−around sqlite3\_prepare\_v2(), sqlite3\_step(), and sqlite3\_finalize(),

80−without having to use a lot of code, though the use of this function is not recommended in this case.

81−

82−The functions finalize\_db and close\_db must be called to clean up the open resources.

83−To print the result, the function toList\_v1 can be used which takes a DBPointer and returns

84−the resulting table.

85−

86−\subsection{More Examples}

87−\label{More Examples}

88−Nested expressions are also supported. You could write queries such as :

89−

90−evalSQL [ ] (SELECT (Cols ["data"]) (SELECT (Cols["num","data"]) (TBL ["tbl1"]) (MkCond (Equals (VCol "num")(VInt 2)))) Empty)

91−

92−Parsed as :

93−

94−SELECT data FROM (SELECT num data FROM tbl1 WHERE num = ?1)

95−

96−Note that in this example, the inner query must include the same column as the outer one otherwise this query will not validate.

97−

98−\subsection{SQL Data Type}

99−\label{SQL Data Type}

100−The SQL Data Types describe the queries that are supported by the library.

101−The implementation of these datatypes is similar to defining a grammar.

102−Data type Value consists of Int, String and Float.

103−The data type can be extended to further support queries.

104−The evaulator function makes use of smaller function to evaulate parts of the query.

105−For instance given a SELECT qeury, it calls \emph{evalSQL} to obtain the list of tables,

106−and clauseString to evaluate the rest of the expression which could include a WHERE clause or could be Empty.

107−

108−

109−\section{Evaluating Queries}

110−\label{Evaluating Queries}

111−The method used here is a divide and conquer manner which divides the query into smaller

112−parts and deals with each part and puts the results together to return a String representation

113−of the query and a list of values.

114−However this could result to a slow type checking process since it needs to go through all

115−the possibilities to type check. Maybe this can be improved?

116−

117−\subsection{evalSQL Function}

118−\label{evalSQL Function}

119−This is a recursive evaluator which makes a call to itself.

120−An SQL could consist of a SELECT ALL or Columns followed by another SQL

121−which could be a nested query or just the name of the table(s).

122−It then call the appropriate functions to evaluate the query.

123−It returns the well-quoted String expression and a list of indexed values which are passed to the bind function.

124−\section{Pointers passed to Idris functions}

125−\label{Pointers passed to Idris functions}

126−

127−The library uses FFI. In order to make the pointers passed to each function more explicit,

128−we have defined them as data types. For instance open\_db takes a String and returns a DBPointer

129−(Database Pointer) and prepare\_db

130−takes a DBPointer and returns a StmtPtr(Statemenet Pointer).

131−Error handling is done using the \emph {DB a} data type which

132−is either \emph {IO String} indicating an error or \emph{ IO a}.

133−To test the functions in main, you need to use runDB :

134−\begin{center}

135−\centering runDB : DB a $\rightarrow$ IO a

136−\end{center}

137−More examples on how to use the functions can be found in \emph{testunit.idr}

138−

139−\section{Using the C Functions}

140−\label{Using the C Functions}

141−The library includes some wrapper functions such as get\_table

142−and exec\_db. Using these functions mixed with prepare, step or finalize

143−inappropriately could cause segmentation faults.

144−Perhaps these functions could be removed from the library if no longer required in the future

145−since the main purpose of this library is to make use of data types.

146−However these functionalities could be implemented internally without calling

147−the C Interface wrapper functions.

148−

149−\section{Further improving the library}

150−\label{Further improving the library}

151−There are many features that could be added to this library. These include adding more useful SQL Commands,

152−extending the SQL datatype to support more complex queries and possibly improving \emph{evalSQL}

153−for a faster performance.

154−Another useful thing to implement is the dot operator(.) which is the member access operator to yield

155−the value of a field in a table. This enables comparing values in different tables and constructing

156−more complex queries.

157−\end{document}

contribs/lib/SQLite3/sqlite3api.cdeleted−543

@@ -1,543 +0,0 @@

1−/*

2− * sqlite3api.c

3− *

4− *

5− * Created by Melissa Farinaz MOZIFIAN on 22/06/2012.

6− * Copyright 2012. All rights reserved.

7− *

8− */

9−

10−

11−#include "sqlite3api.h"

12−

13−

14−// buffer used for storing queries

15−// Used in high-level functions.

16−static char sql_query_buffer[2000];

17−// array used to store the string

18−//value obtain by get_val_text

19−unsigned char* array;

20−/*

21− open an SQLite database file as

22− specified by the filename argument.

23− Returns pointer to DB struct on success

24− Null on failure.

25− */

26−void* sqlite3_open_idr(const char *filename){

27−

28− sqlite3 *db;

29− int res =sqlite3_open(filename,&db);

30−

31− if(res != SQLITE_OK){

32− printf("Error occured while opening the databse.");

33− return NULL;

34− }

35− DBinfo *dbi = malloc(sizeof(DBinfo));

36− dbi->db_ptr = db;

37− return dbi;

38−

39−}

40−/*

41− Frees the resource and returns 0 on success

42− */

43−int sqlite3_close_idr(void* db){

44−

45− DBinfo* dbi =(DBinfo*) db;

46− int res =sqlite3_close(dbi->db_ptr);

47− if (res == SQLITE_OK){

48− free(dbi);

49− return 0;

50− }

51− else {

52− return res;

53− }

54−}

55−/*

56− SQLite wrapper around sqlite3_prepare_v2(),

57− sqlite3_step(), and sqlite3_finalize().

58− This version of exec cannot be used with prepare.

59− For executing queries, must use the exec_db function.

60− */

61−int sqlite3_exec_idr(void* db, const char *sql)

62−{

63− DBinfo* dbi =(DBinfo*) db;

64− char* err;

65− int rc;

66− rc = sqlite3_exec(dbi->db_ptr,sql,NULL, NULL, &err);

67− if (rc != SQLITE_OK && err != NULL) {

68− strncpy(dbi->buffer, err, sizeof(dbi->buffer));

69− sqlite3_free(err);

70− }

71− return rc;

72−}

73−/*

74− Gets the error store in the buffer

75− in the struct. Some certain functions

76− have the feature to store errors in a buffer.

77− */

78−char* sqlite3_get_error(void* db) {

79− DBinfo* dbi =(DBinfo*) db;

80− return dbi->buffer;

81−}

82−/*

83− Compiles the query into a byte-code program

84− Returns a pointer to the sqlite3_stmt pointer

85− and stores it in the struct.

86− */

87−void* sqlite3_prepare_idr(void *db,const char *zSql){

88− sqlite3_stmt* stmt;

89− const char *tail;

90−

91− DBinfo* dbi =(DBinfo*) db;

92−

93− int rec = sqlite3_prepare_v2(dbi->db_ptr,zSql,-1,&stmt,&tail);

94− dbi ->ppStmt =stmt;

95− dbi ->Ptr_tail = tail;

96−

97− if(rec != SQLITE_OK){

98− return NULL;

99− }

100− return dbi;

101−}

102−/*

103− Another wrapper interface that is preserved

104− for backwards compatibility.

105− Use of this interface is not recommended.

106− This was mainly used for testing within the

107− library.

108− */

109−void* sqlite3_get_table_idr(void* db,

110− const char *sql){

111−

112− DBinfo* dbi =(DBinfo*) db;

113− char* err;

114−

115− Table* tbl = malloc(sizeof(Table));

116− tbl->database = dbi;

117− int res = sqlite3_get_table(dbi->db_ptr,sql,&tbl->table_data,&tbl->num_row,&tbl->num_col,&err);

118− int array_size = sizeof(&tbl->table_data);

119−

120− if( res != SQLITE_OK && err != NULL){

121− strncpy(dbi->buffer, err, sizeof(dbi->buffer));

122− sqlite3_free(err);

123− return NULL;

124− }

125− tbl -> data_size = array_size;

126− return tbl;

127−}

128−

129−/*

130− This function executes queries.

131− This can be used after preparing a query

132− In case of error or library misuse

133− it returns 1.

134− It also calls step in order to obtain

135− the row and column number and stores them

136− in the struct. The row number is needed

137− later on in get_data_type function.

138− */

139−int exec_db(void*p){

140−

141− DBinfo* dbi =(DBinfo*) p;

142− int rc, col, row_counter;

143−

144− const char* col_name;

145−

146− rc = sqlite3_step(dbi->ppStmt);

147−

148− if( rc == SQLITE_DONE){

149− return rc;

150− }

151− if(rc == SQLITE_ERROR && rc == SQLITE_MISUSE){

152− return 1;

153− }

154− row_counter =0;

155−

156− while (rc == SQLITE_ROW) {

157−

158− rc = sqlite3_step(dbi->ppStmt);

159− row_counter++;

160− }

161−

162− col = sqlite3_column_count(dbi->ppStmt);

163− dbi->row_count = row_counter;

164− dbi->col_count = col;

165− return rc;

166−}

167−/*

168− Returns row number from DB Struct

169−

170− */

171−int sqlite3_get_num_row_v2(void* p){

172−

173− DBinfo* dbi =(DBinfo*) p;

174− int row_number =dbi->row_count;

175− return row_number;

176−}

177−

178−/*

179− Returns column number from DB Struct

180− */

181−int sqlite3_get_num_col_v2(void* p){

182−

183− DBinfo* dbi =(DBinfo*) p;

184− int col_number =dbi-> col_count;

185− return col_number;

186−}

187−

188−/*

189− Another way of obtaining row number

190− Thought this function gets the value

191− from Table struct. The value is stored

192− in the struct after calling get_table.

193− Using this version is not recommended

194− unless used with get_table

195− */

196−int sqlite3_get_num_row(void* p){

197−

198− Table* tbl =(Table*) p;

199− int row_number =tbl->num_row;

200− return row_number;

201−}

202−

203−/*

204− Another way of obtaining column number

205− Thought this function gets the value

206− from Table struct. The value is stored

207− in the struct after calling get_table.

208− Using this version is not recommended

209− unless used with get_table

210− */

211−int sqlite3_get_num_col(void* p){

212−

213− Table* tbl =(Table*) p;

214− int col_number =tbl-> num_col;

215− return col_number;

216−}

217−

218−/*

219− This routine returns the type of value

220− and must be called after prepare and exec.

221− Since exec steps through database to obtain

222− row number, this function calls reset to

223− set the pointer to its initial state

224− and then calls sqlite3_column_type

225− to get the type

226−*/

227−int sqlite3_get_data_type(void* p, int nRow, int nCol){

228−

229− DBinfo* dbi =(DBinfo*) p;

230− int rc, type, row_counter;

231− const char* char_int;

232−

233− rc = sqlite3_reset(dbi->ppStmt);

234− rc = sqlite3_step(dbi->ppStmt);

235− row_counter =0;

236−

237− while (rc == SQLITE_ROW && row_counter < nRow) {

238−

239− rc = sqlite3_step(dbi->ppStmt);

240− row_counter++;

241− }

242− type =sqlite3_column_type(dbi->ppStmt, nCol);

243− return type;

244−

245−}

246−/*

247− Obtains the integer value in a given column

248−*/

249−

250−int sqlite3_get_val_int(void* p, int nCol){

251−

252− DBinfo* dbi =(DBinfo*) p;

253− int val, col;

254− val =sqlite3_column_int(dbi->ppStmt, nCol);

255− return val;

256−}

257−

258−/*

259− Obtains the text value

260− Need to allocate memory to store the string

261− Use GC_malloc since Boehm garbage collector

262− frees the resources .

263− */

264−const unsigned char* sqlite3_get_val_text(void* p,int nCol){

265−

266−

267− DBinfo* dbi =(DBinfo*) p;

268− int rc,i, val, counter;

269− const unsigned char* text_val;

270− array =(unsigned char *) malloc(1000*sizeof(char));

271− text_val =sqlite3_column_text(dbi->ppStmt, nCol);

272− memcpy(array, text_val, strlen(text_val));

273− return array;

274−

275−}

276−float sqlite3_get_float(void* p, int nCol){

277−

278− DBinfo* dbi =(DBinfo*) p;

279− double double_val;

280−

281− double_val =sqlite3_column_double(dbi->ppStmt, nCol);

282− float float_val =(float)double_val;

283− return float_val;

284−

285−}

286−/*

287− frees the pointer returned by get_table.

288− */

289−

290−void sqlite3_free_table_idr(void* db){

291− Table* tbl =(Table*) db;

292− sqlite3_free_table(tbl->table_data);

293− free(tbl);

294−}

295−int sqlite3_step_idr(void* db){

296−

297− DBinfo* dbi =(DBinfo*) db;

298− int rc =sqlite3_step(dbi->ppStmt);

299− return rc;

300−}

301−/*

302− Binds integer. This returns a pointer

303− because of the implementation of BindMulti

304− which binds multiple values

305− */

306−void* sqlite3_bind_int_idr(void* p,int index, int val){

307−

308− DBinfo* dbi =(DBinfo*) p;

309− int rc;

310−

311− rc =sqlite3_bind_int(dbi->ppStmt,index,val);

312− if(rc != SQLITE_OK){

313− return NULL;

314− }

315−

316− return dbi;

317−}

318−

319−void* sqlite3_bind_float_idr(void* p,int index, float val){

320−

321− DBinfo* dbi =(DBinfo*) p;

322− int rc;

323− double res =(float)val;

324−

325− rc =sqlite3_bind_double(dbi->ppStmt,index,res);

326−

327− if(rc != SQLITE_OK){

328− return NULL;

329− }

330− return dbi;

331−}

332−

333−void* sqlite3_bind_null_idr(void* p,int index){

334−

335− DBinfo* dbi =(DBinfo*) p;

336− int rc;

337− rc =sqlite3_bind_null(dbi->ppStmt,index);

338− if(rc != SQLITE_OK){

339− return NULL;

340− }

341−

342− return dbi;

343−}

344−

345−void* sqlite3_bind_text_idr(void* p,const char* text, int index,int length){

346−

347− DBinfo* dbi =(DBinfo*) p;

348− int rc;

349− rc =sqlite3_bind_text(dbi->ppStmt,index,text,length,SQLITE_STATIC);

350− if(rc != SQLITE_OK){

351− return NULL;

352− }

353−

354− return dbi;

355−}

356−/*

357− Used for testing column count function.

358− This function prepares query and by passing

359− select all, gets the count for column number

360− Could be used for testing. Not recommended to

361− be used with prepare and exec

362− */

363−

364−int sqlite3_column_count_idr(void* db, const char* tbl_name){

365− DBinfo* dbi =(DBinfo*) db;

366− sqlite3_stmt* stmt;

367− const char *tail;

368− int rc;

369−

370− strcpy(sql_query_buffer, "select * from ");

371− strcat(sql_query_buffer, tbl_name);

372−

373− rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);

374− if(rc != SQLITE_OK){

375− fprintf(stderr, "SQL Prepare error");

376− return rc;

377− }

378− printf("Prepare successful %d\n", rc);

379−

380− rc =sqlite3_column_count(stmt);

381− if(rc == 0){

382− fprintf(stderr, "SQL column count error\n");

383− return rc;

384− }

385− sqlite3_finalize(stmt);

386−

387− // rc = actual column count

388− return rc;

389−}

390−

391−int sqlite3_data_count_idr(void* db){

392−

393− DBinfo* dbi =(DBinfo*) db;

394− int rc = sqlite3_data_count(dbi->ppStmt);

395−

396− return rc;

397−}

398−/*

399− Must be called after prepare to clean up

400− the resources.

401− */

402−int sqlite3_finalize_idr(void* db){

403−

404− DBinfo* dbi=(DBinfo*) db;

405− int rc =sqlite3_finalize(dbi->ppStmt);

406− return rc;

407−}

408−

409−int sqlite3_complete_idr(const char *sql){

410−

411− int rc = sqlite3_complete(sql);

412− return rc;

413−}

414−

415−/*

416− Resets a prepared statement pointer

417− to its initial state

418− */

419−int sqlite3_reset_idr(void* db){

420−

421− DBinfo* dbi=(DBinfo*) db;

422− int rc = sqlite3_reset(dbi-> ppStmt);

423− return rc;

424−

425−}

426−/*

427− The following routines may be used to

428− obtain column related information.

429− */

430−const char *sqlite3_column_name_idr(void* db, int N){

431−

432− DBinfo* dbi=(DBinfo*) db;

433− const char *name = sqlite3_column_name(dbi->ppStmt, N);

434−

435− return name;

436−}

437−

438−const char *sqlite3_column_decltype_idr(void* db,int n){

439− DBinfo* dbi=(DBinfo*) db;

440− const char *dectype = sqlite3_column_decltype(dbi->ppStmt, n);

441−

442− return dectype;

443−

444−}

445−int sqlite3_column_bytes_idr(void* db, int n){

446−

447− DBinfo* dbi=(DBinfo*) db;

448− int res = sqlite3_column_bytes(dbi->ppStmt, n);

449− return res;

450−

451−

452−}

453−const void *sqlite3_column_blob_idr(void* db, int iCol){

454− DBinfo* dbi=(DBinfo*) db;

455− const void* data =sqlite3_column_blob(dbi-> ppStmt, iCol);

456− return data;

457−}

458−

459−const unsigned char *sqlite3_column_text_idr(void* db, int iCol){

460− DBinfo* dbi=(DBinfo*) db;

461− const unsigned char* col_text =sqlite3_column_text(dbi->ppStmt, iCol);

462− return col_text;

463−

464−}

465−

466−int sqlite3_column_int_idr(void* db, int iCol){

467− DBinfo* dbi=(DBinfo*) db;

468− int res =sqlite3_column_int(dbi-> ppStmt, iCol);

469− return res;

470−

471−}

472−/*

473− Some back up functions

474− */

475−

476−void* sqlite3_backup_init_idr(void* pDest,

477− const char *zDestName,

478− void* pSource,

479− const char *zSourceName

480− ){

481−

482− DBinfo* dbi=(DBinfo*) pDest;

483− DBbackup* dbi2=(DBbackup*) pSource;

484−

485− void* res = sqlite3_backup_init(dbi->db_ptr,zDestName,

486− dbi2->source_ptr,zSourceName);

487−

488− if(res == NULL){

489− printf("Error number in initializing backup : %d\n", sqlite3_errcode(dbi->db_ptr));

490− }

491−

492− dbi2->backup = res;

493− return dbi2;

494−

495−

496−}

497−

498−int sqlite3_backup_step_idr(void *backup, int nPage){

499−

500− DBbackup* dbi=(DBbackup*) backup;

501− int res = sqlite3_backup_step(dbi->backup, nPage);

502− return res;

503−

504−

505−}

506−int sqlite3_backup_finish_idr(void *backup){

507−

508− DBbackup* dbi=(DBbackup*) backup;

509− int res = sqlite3_backup_finish(dbi->backup);

510− return res;

511−

512−

513−}

514−

515−int sqlite3_backup_remaining_idr(void *backup){

516−

517− DBbackup* dbi=(DBbackup*) backup;

518− int res = sqlite3_backup_remaining(dbi->backup);

519−

520− return res;

521−}

522−

523−int sqlite3_backup_pagecount_idr(void *backup){

524−

525− DBbackup* dbi=(DBbackup*) backup;

526− int res =sqlite3_backup_pagecount(dbi-> backup);

527− return res;

528−

529−}

530−/*

531− Get the length of string

532− Need this in Idris since length will not

533− work on Strings.

534− */

535−int strLength(const char * str){

536−

537− int length = strlen(str);

538− return length;

539−

540−

541−}

542−

543−

contribs/lib/SQLite3/sqlite3api.hdeleted−130

@@ -1,130 +0,0 @@

1−/*

2− * sqlite3api.h

3− *

4− *

5− * Created by Melissa Farinaz MOZIFIAN on 22/06/2012.

6− * Copyright 2012. All rights reserved.

7− *

8− */

9−#include <stdio.h>

10−#include <stdlib.h>

11−#include <string.h>

12−#include <sqlite3.h>

13−#include <ctype.h>

14−#include <gc.h>

15−

16−typedef struct {

17− sqlite3 *db_ptr; // database pointer

18− sqlite3_stmt *ppStmt; // statement pointer

19− char buffer[1000]; // bufer to store errors returned by certain functions

20− const char *Ptr_tail;

21− sqlite3_value *value;

22− int row_count; // row number store by exec function

23− int col_count;

24−

25−} DBinfo;

26−

27−// struct used for backup functions

28−typedef struct {

29− sqlite3 *source_ptr;

30− sqlite3_backup *backup;

31−}DBbackup ;

32−

33−// Table struct used by get_table function

34−// stores row and column

35−// returned by get_table

36−typedef struct {

37− int num_row;

38− int num_col;

39− char** table_data;

40− int data_size;

41− int* data_type;

42− DBinfo* database;

43−}Table;

44−

45−

46−void* sqlite3_open_idr(const char *filename);

47−

48−int exec_db(void*p);

49−

50−int sqlite3_close_idr(void* db);

51−

52−int sqlite3_exec_idr(void*, const char *sql);

53−

54−char* sqlite3_get_error(void* db);

55−

56−const unsigned char* sqlite3_get_val_text(void* p,int nCol);

57−

58−void* sqlite3_get_table_idr(void* db, const char *sql);

59−

60−void sqlite3_free_table_idr(void* db);

61−

62−int sqlite3_get_num_col(void* p);

63−

64−int sqlite3_get_num_row(void* p);

65−

66−int sqlite3_get_num_row_v2(void* p);

67−

68−int sqlite3_get_num_col_v2(void* p);

69−

70−int sqlite3_get_data_type(void* p, int nRow, int nCol);

71−

72−int sqlite3_get_val_int(void* p,int nCo);

73−

74−float sqlite3_get_float(void* p, int nCol);

75−

76−void* sqlite3_prepare_idr(

77− void *db, /* Database handle */

78− const char *zSql /* SQL statement, UTF-8 encoded */

79−);

80−

81−int sqlite3_step_idr(void* stmt);

82−

83−void* sqlite3_bind_float_idr(void* p,int index, float val);

84−

85−void* sqlite3_bind_int_idr(void* p,int index , int val);

86−

87−void* sqlite3_bind_null_idr(void* p,int index);

88−

89−void* sqlite3_bind_text_idr(void* p,const char* text, int index,int length);

90−

91−int sqlite3_column_count_idr(void* stmt, const char* tbl_name);

92−

93−int sqlite3_data_count_idr(void* stmt);

94−

95−int sqlite3_reset_idr(void* stmt);

96−

97−int sqlite3_finalize_idr(void* stmt);

98−

99−int sqlite3_complete_idr(const char *sql);

100−

101−const char *sqlite3_column_decltype_idr(void* stmt,int n);

102−

103−const char *sqlite3_column_name_idr(void* stmt, int N);

104−

105−int sqlite3_column_bytes_idr(void* stmt, int n);

106−

107−int sqlite3_column_bytes_idr(void* stmt, int n);

108−

109−const void *sqlite3_column_blob_idr(void* stmt, int iCol);

110−

111−const unsigned char *sqlite3_column_text_idr(void* stmt, int iCol);

112−

113−int sqlite3_column_int_idr(void* stmt, int iCol);

114−

115−

116−void* sqlite3_backup_init_idr(void* pDestm,

117− const char *zDestName,

118− void* pSource,

119− const char *zSourceName

120− );

121−

122−int sqlite3_backup_finish_idr(void *backup);

123−

124−int sqlite3_backup_step_idr(void *backup, int nPage);

125−

126−int sqlite3_backup_remaining_idr(void *backup);

127−

128−int sqlite3_backup_pagecount_idr(void *backup);

129−

130−int strLength(const char * str);

contribs/lib/SQLite3/students.dbdeleted

Binary file not shown.

contribs/lib/SQLite3/testunit.idrdeleted−140

@@ -1,140 +0,0 @@

1−module Main

2−import Sqlite3

3−

4−

5−testexpr : DB()

6−testexpr = do db <- open_db "somedb.db"

7− let sql = (evalSQL [] ((SELECT ALL)(TBL ["tbl1"]) (OR (AND (MkCond (Equals (VCol "data")(VStr "data0"))) (MkCond (Equals (VCol "num")(VInt 1))) ) (MkCond (Equals (VCol "num")(VInt 2))))))

8− let x = (fst sql) -- get the string

9− let list = (snd sql) -- list of vals

10− liftIO(print x) -- use liftIO to turn this into DB type

11− stmt <- (prepare_db db x) -- prepare the statement

12− bindMulti stmt list -- bind the values in the list

13− exec_db_v2 stmt -- execute the prepared query

14− res <- toList_v1 db -- toList_v1 to get the result

15− liftIO(print res) -- print the result

16− finalize_db stmt -- Statment pointer must be finalized in the end

17− close_db db -- close the datbase

18− return ()

19−

20−testupdate : DB()

21−testupdate = do db <- open_db "somedb.db"

22− let sql = (evalSQL [] (UPDATE (TBL ["tbl1"]) (WHERE (SET (MkCond (Equals(VCol "data") (VStr "data600"))) ) (MkCond (Equals (VCol "num") (VInt 2))) ) ))

23− let x = (fst sql)

24− let list = (snd sql)

25− liftIO(print x)

26− stmt <- (prepare_db db x)

27− bindMulti stmt list

28− exec_db_v2 stmt

29− finalize_db stmt

30− close_db db

31− return ()

32−

33−testInsert : DB()

34−testInsert = do db <- open_db "somedb.db"

35− let sql = (evalSQL [] (INSERT (TBL ["tbl1"]) [(VInt 3),(VStr "ham")]))

36− let x = (fst sql)

37− let list = (snd sql)

38− liftIO(print x)

39− stmt <- (prepare_db db x)

40− bindMulti stmt list

41− exec_db_v2 stmt

42− finalize_db stmt

43− close_db db

44− return ()

45−

46−testNull : DB()

47−testNull = do db <- open_db "somedb.db"

48− let sql = (evalSQL [] ((SELECT ALL)(TBL ["tbl1"]) (MkCond (MkNULL (VCol "data")))))

49− let x = (fst sql)

50− let list = (snd sql)

51− liftIO(print x)

52− stmt <- (prepare_db db x)

53− bindMulti stmt list

54− exec_db_v2 stmt

55− res <- toList_v1 db

56− liftIO(print res)

57− finalize_db stmt

58− close_db db

59− return ()

60−

61−

62−testInsertWithCond : DB()

63−testInsertWithCond = do db <- open_db "somedb.db"

64− let sql = (evalSQL [] (INSERTC (TBL ["tbl1"]) [(VCol "data"),(VCol "num")] [(VInt 30),(VStr "inserthere")]))

65− let x = (fst sql)

66− let list = (snd sql)

67− liftIO(print x)

68− stmt <- (prepare_db db x)

69− bindMulti stmt list

70− exec_db_v2 stmt

71− finalize_db stmt

72− close_db db

73− return ()

74−

75−-- Nested queries need to have the same column as the outer queries.

76−testNestedSel1 : DB()

77−testNestedSel1 = do db <- open_db "somedb.db"

78− let sql = (evalSQL [] (SELECT (Cols ["data"]) (SELECT (Cols["num","data"]) (TBL ["tbl1"]) (MkCond (MkGT (VCol "num")(VInt 2))))Empty))

79− let x = (fst sql)

80− let list = (snd sql)

81− liftIO(print x)

82− stmt <- (prepare_db db x)

83− bindMulti stmt list

84− exec_db_v2 stmt

85− res <- toList_v1 db

86− liftIO(print res)

87− finalize_db stmt

88− close_db db

89− return ()

90−

91−-- Testing Create Table

92−testCreateTable : DB ()

93−testCreateTable = do db <- open_db "somedb.db"

94− let sql = (evalSQL [] (CREATE (TBL ["mynewtbl"]) [ ((VCol "col"),(CInt "int"),(None)) ] ) )

95− let x = (fst sql)

96− let list = (snd sql)

97− liftIO(print x)

98− stmt <- (prepare_db db x)

99− bindMulti stmt list

100− exec_db_v2 stmt

101− finalize_db stmt

102− close_db db

103− return ()

104−

105−-- This may be a bit slow

106−testMultiTable : DB ()

107−testMultiTable = do db <- open_db "somedb.db"

108− let sql = (evalSQL [] ((SELECT ALL )(TBL ["mytable","tbl1"]) (Empty) ) )

109− let x = (fst sql)

110− let list = (snd sql)

111− liftIO(print x)

112− stmt <- (prepare_db db x)

113− bindMulti stmt list

114− exec_db_v2 stmt

115− res <- toList_v1 db

116− liftIO(print res)

117− finalize_db stmt

118− close_db db

119− return ()

120−

121−testSelAll : DB ()

122−testSelAll = do db <- open_db "somedb.db"

123− let sql = (evalSQL [] ((SELECT ALL )(TBL ["tbl1"]) (Empty) ) )

124− let x = (fst sql)

125− let list = (snd sql)

126− liftIO(print x)

127− stmt <- (prepare_db db x)

128− bindMulti stmt list

129− exec_db_v2 stmt

130− res <- toList_v1 db

131− liftIO(print res)

132− finalize_db stmt

133− close_db db

134− return ()

135−

136−

137−main : IO ()

138−main = do x <- runDB (testMultiTable) -- runDB : DB a -> IO a

139− --y <- runDB (testNestedSel1)

140− return ()

contribs/lib/SimpleParser/SimpleParser.idrdeleted−188

@@ -1,188 +0,0 @@

1−{-

2− Simple monadic parser module, based heavily on that by

3− Graham Hutton.

4−-}

5−

6−module SimpleParser

7−

8−import Prelude

9−import Prelude.Monad

10−import Prelude.Applicative

11−import Prelude.List

12−import Builtins

13−

14−%access public

15−

16−

17−--------------------------------------------------------------------------------

18−-- The monad of parsers

19−--------------------------------------------------------------------------------

20−

21−data Parser a = P (String -> Either String (a, String))

22−

23−parse : Parser a -> String -> Either String (a, String)

24−parse (P p) inp = p inp

25−

26−instance Functor Parser where

27− map f p = P (\inp => case parse p inp of

28− Left err => Left err

29− Right (v, rest) => Right ((f v), rest))

30−

31−instance Applicative Parser where

32− pure v = P (\inp => Right (v, inp))

33− a <$> b = P (\inp => do (f, rest) <- parse a inp

34− (x, rest') <- parse b rest

35− pure ((f x), rest'))

36−

37−instance Monad Parser where

38− p >>= f = P (\inp => case parse p inp of

39− Left err => Left err

40− Right (v,rest) => parse (f v) rest)

41−

42−instance Alternative Parser where

43− empty = P (const (Left "empty"))

44− p <|> q = P (\inp => case parse p inp of

45− Left msg => parse q inp

46− Right (v,out) => Right (v,out))

47−

48−

49−--------------------------------------------------------------------------------

50−-- Basic parsers

51−--------------------------------------------------------------------------------

52−

53−failure : String -> Parser a

54−failure msg = P (\inp => Left msg)

55−

56−item : Parser Char

57−item = P (\inp => case choose (inp == "") of

58− Left _ => Left "Error! Parsing empty list."

59− Right p => Right (strHead' inp p, strTail' inp p))

60−

61−

62−--------------------------------------------------------------------------------

63−-- Derived primitives

64−--------------------------------------------------------------------------------

65−

66−sat : (Char -> Bool) -> Parser Char

67−sat p = do x <- item

68− guard (p x)

69− pure x

70−

71−oneof : List Char -> Parser Char

72−oneof xs = sat (\x => elem x xs)

73−

74−digit : Parser Char

75−digit = sat isDigit

76−

77−lower : Parser Char

78−lower = sat isLower

79−

80−upper : Parser Char

81−upper = sat isUpper

82−

83−letter : Parser Char

84−letter = sat isAlpha

85−

86−alphanum : Parser Char

87−alphanum = sat isAlphaNum

88−

89−char : Char -> Parser Char

90−char x = sat (== x)

91−

92−string : String -> Parser String

93−string s = map pack (traverse char (unpack s))

94−

95−mutual

96− many1 : Parser a -> Parser (List a)

97− many1 p = [| p :: many p |]

98−

99− many : Parser a -> Parser (List a)

100− many p = lazy (many1 p) <|> pure []

101−

102−bool : Parser Bool

103−bool = parseTrue <|> parseFalse

104− where parseTrue : Parser Bool

105− parseTrue = do oneof ['T', 't']

106− string "rue"

107− pure True

108− parseFalse = do oneof ['F', 'f']

109− string "alse"

110− pure False

111−

112−ident : Parser String

113−ident = map pack [| letter :: many1 alphanum |]

114−

115−nat : Parser Int

116−nat = do xs <- many digit

117− pure (cast (cast xs))

118−

119−int : Parser Int

120−int = neg <|> nat

121− where neg : Parser Int

122− neg = do char '-'

123− n <- nat

124− pure (-n)

125−

126−space : Parser ()

127−space = do many (sat isSpace)

128− pure ()

129−

130−

131−--------------------------------------------------------------------------------

132−-- Ignoring spacing

133−--------------------------------------------------------------------------------

134−

135−token : Parser a -> Parser a

136−token p = space $> p <$ space

137−

138−identifier : Parser String

139−identifier = token ident

140−

141−natural : Parser Int

142−natural = token nat

143−

144−integer : Parser Int

145−integer = token int

146−

147−symbol : String -> Parser String

148−symbol xs = token (string xs)

149−

150−strToken : Parser String

151−strToken = map pack (token (many1 alphanum))

152−

153−--------------------------------------------------------------------------------

154−-- combinators

155−--------------------------------------------------------------------------------

156−

157−optional : Parser a -> Parser (Maybe a)

158−optional p = map Just p <|> pure Nothing

159−

160−sepBy1 : Parser a -> Parser b -> Parser (List a)

161−sepBy1 p s = [| p :: many (s $> p) |]

162−

163−sepBy : Parser a -> Parser b -> Parser (List a)

164−sepBy p s = sepBy1 p s <|> pure Nil

165−

166−manyTil : Parser a -> Parser b -> Parser (List a)

167−manyTil p e = (e $> pure Nil) <|> lazy [| p :: manyTil p e |] <|> pure Nil

168−

169−--------------------------------------------------------------------------------

170−-- Expressions

171−--------------------------------------------------------------------------------

172−

173−expr : Parser Int

174−factor : Parser Int

175−term : Parser Int

176−

177−expr = do t <- term

178− map (t+) (symbol "+" $> expr) <|> pure t

179−

180−factor = (symbol "(" $> expr <$ symbol ")") <|> natural

181−

182−term = do f <- factor

183− map (f*) (symbol "*" $> term) <|> pure f

184−

185−eval : String -> Maybe Int

186−eval xs = case (parse expr xs) of

187− Right (n,rest) => if rest == "" then Just n else Nothing

188− Left msg => Nothing

contribs/tool-support/completion/idris.bashdeleted−31

@@ -1,31 +0,0 @@

1−_idris() {

2− local cur prev words opts LIBRARIES TARGETS

3− _init_completion || return

4−

5− opts=$(_parse_help "$1")

6− LIBRARIES="effects"

7− TARGETS="C Java bytecode javascript node"

8−

9− case "${prev}" in

10− -o)

11− _filedir

12− ;;

13− -i|--ibcsubdir)

14− _filedir -d

15− ;;

16− -p)

17− COMPREPLY=( $(compgen -W "${LIBRARIES}" -- ${cur}))

18− ;;

19− --target)

20− COMPREPLY=( $(compgen -W "${TARGETS}" -- ${cur}))

21− ;;

22− esac

23−

24− if [[ $cur == -* ]]; then

25− COMPREPLY=($(compgen -W "${opts}" -- ${cur}))

26− return

27− fi

28−

29− _filedir '@(idr)'

30−} &&

31−complete -o default -F _idris idris

contribs/tool-support/sublime-text/Idris/Idris.JSON-tmLanguagedeleted−70

@@ -1,70 +0,0 @@

1−{ "name": "Idris",

2− "scopeName": "source.idris",

3− "fileTypes": ["idr"],

4− "patterns": [

5− { "name": "keyword.control.idris",

6− "match": "\\b(if|then|else|do|let|in|data|codata|record|dsl|import)\\b"

7−

8− },

9− { "name": "keyword.control.idris",

10− "match": "\\b(impossible|case|of|total|partial|mutual|infix|infixl|infixr)\\b"

11−

12− },

13− { "name": "keyword.control.idris",

14− "match": "\\b(where|with|syntax|proof|postulate|using|namespace|class|instance)\\b"

15−

16− },

17− { "name": "keyword.control.idris",

18− "match": "\\b(public|private|abstract|implicit)\\b"

19−

20− },

21− { "name": "keyword.other.idris",

22− "match": "\\b(Type|Int|Integer|Float|Char|String|Ptr|Bits8|Bits16|Bits32|Bits64)\\b"

23− },

24− { "name": "constant.numeric.idris",

25− "match": "\\b(S|O)\\b"

26− },

27− { "match": "\\b([0-9]+|0([xX][0-9a-fA-F]+|[oO][0-7]+))\\b",

28− "name": "constant.numeric.idris",

29− "comment": "integers"

30− },

31− {

32− "match": "\\b([0-9]+\\.[0-9]+([eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)\\b",

33− "name": "constant.numeric.float.idris",

34− "comment": "floats"

35− },

36− {

37− "name": "comment.line.idris",

38− "match": "(--).*$\n?",

39− "comment": "Line comment"

40− },

41− { "name": "comment.block.idris",

42− "begin": "\\{-",

43− "end": "-\\}",

44− "comment": "Block comment"

45− },

46− {

47− "name": "string.quoted.idris",

48− "begin": "\"",

49− "beginCaptures": {

50− "0": { "name": "punctuation.definition.string.begin.idris"}

51− },

52− "end": "\"",

53− "endCaptures": {

54− "0": { "name": "punctuation.definition.string.end.idris"}

55− },

56− "patterns": [

57− { "name": "constant.character.escape.idris",

58− "match": "\\\\\""

59− }

60− ]

61−

62− }

63−

64−

65− ],

66− "repository": {

67−

68− },

69− "uuid": "4dd16092-ffa5-4ba4-8075-e5da9f368a72"

70−}

contribs/tool-support/sublime-text/Idris/Idris.tmLanguagedeleted−126

@@ -1,126 +0,0 @@

1−<?xml version="1.0" encoding="UTF-8"?>

2−<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

3−<plist version="1.0">

4−<dict>

5− <key>fileTypes</key>

6− <array>

7− <string>idr</string>

8− </array>

9− <key>name</key>

10− <string>Idris</string>

11− <key>patterns</key>

12− <array>

13− <dict>

14− <key>match</key>

15− <string>\b(if|then|else|do|let|in|data|codata|record|dsl|import)\b</string>

16− <key>name</key>

17− <string>keyword.control.idris</string>

18− </dict>

19− <dict>

20− <key>match</key>

21− <string>\b(impossible|case|of|total|partial|mutual|infix|infixl|infixr)\b</string>

22− <key>name</key>

23− <string>keyword.control.idris</string>

24− </dict>

25− <dict>

26− <key>match</key>

27− <string>\b(where|with|syntax|proof|postulate|using|namespace|class|instance)\b</string>

28− <key>name</key>

29− <string>keyword.control.idris</string>

30− </dict>

31− <dict>

32− <key>match</key>

33− <string>\b(public|private|abstract|implicit)\b</string>

34− <key>name</key>

35− <string>keyword.control.idris</string>

36− </dict>

37− <dict>

38− <key>match</key>

39− <string>\b(Type|Int|Integer|Float|Char|String|Ptr|Bits8|Bits16|Bits32|Bits64)\b</string>

40− <key>name</key>

41− <string>keyword.other.idris</string>

42− </dict>

43− <dict>

44− <key>match</key>

45− <string>\b(S|O)\b</string>

46− <key>name</key>

47− <string>constant.numeric.idris</string>

48− </dict>

49− <dict>

50− <key>comment</key>

51− <string>integers</string>

52− <key>match</key>

53− <string>\b([0-9]+|0([xX][0-9a-fA-F]+|[oO][0-7]+))\b</string>

54− <key>name</key>

55− <string>constant.numeric.idris</string>

56− </dict>

57− <dict>

58− <key>comment</key>

59− <string>floats</string>

60− <key>match</key>

61− <string>\b([0-9]+\.[0-9]+([eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)\b</string>

62− <key>name</key>

63− <string>constant.numeric.float.idris</string>

64− </dict>

65− <dict>

66− <key>comment</key>

67− <string>Line comment</string>

68− <key>match</key>

69− <string>(--).*$

70−?</string>

71− <key>name</key>

72− <string>comment.line.idris</string>

73− </dict>

74− <dict>

75− <key>begin</key>

76− <string>\{-</string>

77− <key>comment</key>

78− <string>Block comment</string>

79− <key>end</key>

80− <string>-\}</string>

81− <key>name</key>

82− <string>comment.block.idris</string>

83− </dict>

84− <dict>

85− <key>begin</key>

86− <string>"</string>

87− <key>beginCaptures</key>

88− <dict>

89− <key>0</key>

90− <dict>

91− <key>name</key>

92− <string>punctuation.definition.string.begin.idris</string>

93− </dict>

94− </dict>

95− <key>end</key>

96− <string>"</string>

97− <key>endCaptures</key>

98− <dict>

99− <key>0</key>

100− <dict>

101− <key>name</key>

102− <string>punctuation.definition.string.end.idris</string>

103− </dict>

104− </dict>

105− <key>name</key>

106− <string>string.quoted.idris</string>

107− <key>patterns</key>

108− <array>

109− <dict>

110− <key>match</key>

111− <string>\\"</string>

112− <key>name</key>

113− <string>constant.character.escape.idris</string>

114− </dict>

115− </array>

116− </dict>

117− </array>

118− <key>repository</key>

119− <dict>

120− </dict>

121− <key>scopeName</key>

122− <string>source.idris</string>

123− <key>uuid</key>

124− <string>4dd16092-ffa5-4ba4-8075-e5da9f368a72</string>

125−</dict>

126−</plist>

contribs/tool-support/sublime-text/Idris/idris.sublime-builddeleted−5

@@ -1,5 +0,0 @@

1−{

2− "cmd": ["idris", "$file"],

3− "file_regex": "^(...*?):([0-9]*):?([0-9]*)",

4− "selector": "source.idris"

5−}

contribs/tool-support/sublime-text/README.mddeleted−11

@@ -1,11 +0,0 @@

1−#### Idris support for Sublime Text 2

2−

3−To install, copy the Idris directory to Sublime Text's Packages directory.

4−

5−To build a new Idris.tmLanguage file from the Idris.JSON-tmLanguage file, Sublime Text needs to have the AAAPackageDev package installed.

6−

7−Syntax Definitions tutorial: https://sublime-text-unofficial-documentation.readthedocs.org/en/latest/extensibility/syntaxdefs.html

8−

9−Syntax Definitions reference: https://sublime-text-unofficial-documentation.readthedocs.org/en/latest/reference/syntaxdefs.html

10−

11−Most used scopes: http://manual.macromates.com/en/language_grammars#naming_conventions

custom.mk-alldeps+1−2

@@ -1,2 +1 @@

1−CABALFLAGS += -f LLVM -f FFI

2−

1+CABALFLAGS += -f GMP -f FFI --disable-documentation --disable-profiling --disable-library-profiling

docs/.gitignorenew file+3

@@ -0,0 +1,3 @@

1+*~

2+UnicodeData.txt

3+_build/

docs/LICENSEnew file+10

@@ -0,0 +1,10 @@

1+#+TITLE: Licensing Information

2+

3+The documentation for Idris has been published under the Creative

4+Commons CC0 License. As such to the extent possible under law, /The

5+Idris Community/ has waived all copyright and related or neighboring

6+rights to Documentation for Idris.

7+

8+More information concerning the CC0 can be found online at:

9+

10+ https://creativecommons.org/publicdomain/zero/1.0/

docs/Makefilenew file+183

@@ -0,0 +1,183 @@

1+# Makefile for Sphinx documentation

2+#

3+

4+# You can set these variables from the command line.

5+SPHINXOPTS =

6+SPHINXBUILD = sphinx-build

7+PAPER =

8+BUILDDIR = _build

9+

10+# User-friendly check for sphinx-build

11+ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)

12+$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from https://www.sphinx-doc.org/)

13+endif

14+

15+# Internal variables.

16+PAPEROPT_a4 = -D latex_paper_size=a4

17+PAPEROPT_letter = -D latex_paper_size=letter

18+ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .

19+# the i18n builder cannot share the environment and doctrees with the others

20+I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .

21+

22+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest coverage gettext

23+

24+help:

25+ @echo "Please use \`make <target>' where <target> is one of"

26+ @echo " html to make standalone HTML files"

27+ @echo " dirhtml to make HTML files named index.html in directories"

28+ @echo " singlehtml to make a single large HTML file"

29+ @echo " pickle to make pickle files"

30+ @echo " json to make JSON files"

31+ @echo " htmlhelp to make HTML files and a HTML help project"

32+ @echo " qthelp to make HTML files and a qthelp project"

33+ @echo " devhelp to make HTML files and a Devhelp project"

34+ @echo " epub to make an epub"

35+ @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"

36+ @echo " latexpdf to make LaTeX files and run them through pdflatex"

37+ @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx"

38+ @echo " text to make text files"

39+ @echo " man to make manual pages"

40+ @echo " texinfo to make Texinfo files"

41+ @echo " info to make Texinfo files and run them through makeinfo"

42+ @echo " gettext to make PO message catalogs"

43+ @echo " changes to make an overview of all changed/added/deprecated items"

44+ @echo " xml to make Docutils-native XML files"

45+ @echo " pseudoxml to make pseudoxml-XML files for display purposes"

46+ @echo " linkcheck to check all external links for integrity"

47+ @echo " doctest to run all doctests embedded in the documentation (if enabled)"

48+ @echo " coverage to run coverage check of the documentation (if enabled)"

49+

50+clean:

51+ rm -rf $(BUILDDIR)/*

52+

53+html:

54+ $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html

55+ @echo

56+ @echo "Build finished. The HTML pages are in $(BUILDDIR)/html."

57+

58+dirhtml:

59+ $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml

60+ @echo

61+ @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."

62+

63+singlehtml:

64+ $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml

65+ @echo

66+ @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."

67+

68+pickle:

69+ $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle

70+ @echo

71+ @echo "Build finished; now you can process the pickle files."

72+

73+json:

74+ $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json

75+ @echo

76+ @echo "Build finished; now you can process the JSON files."

77+

78+htmlhelp:

79+ $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp

80+ @echo

81+ @echo "Build finished; now you can run HTML Help Workshop with the" \

82+ ".hhp project file in $(BUILDDIR)/htmlhelp."

83+

84+qthelp:

85+ $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp

86+ @echo

87+ @echo "Build finished; now you can run "qcollectiongenerator" with the" \

88+ ".qhcp project file in $(BUILDDIR)/qthelp, like this:"

89+ @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/IdrisManual.qhcp"

90+ @echo "To view the help file:"

91+ @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/IdrisManual.qhc"

92+

93+devhelp:

94+ $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp

95+ @echo

96+ @echo "Build finished."

97+ @echo "To view the help file:"

98+ @echo "# mkdir -p $$HOME/.local/share/devhelp/IdrisManual"

99+ @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/IdrisManual"

100+ @echo "# devhelp"

101+

102+epub:

103+ $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub

104+ @echo

105+ @echo "Build finished. The epub file is in $(BUILDDIR)/epub."

106+

107+latex:

108+ $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex

109+ @echo

110+ @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."

111+ @echo "Run \`make' in that directory to run these through (pdf)latex" \

112+ "(use \`make latexpdf' here to do that automatically)."

113+

114+latexpdf:

115+ $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex

116+ @echo "Running LaTeX files through pdflatex..."

117+ $(MAKE) -C $(BUILDDIR)/latex all-pdf

118+ @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."

119+

120+latexpdfja:

121+ $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex

122+ @echo "Running LaTeX files through platex and dvipdfmx..."

123+ $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja

124+ @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."

125+

126+text:

127+ $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text

128+ @echo

129+ @echo "Build finished. The text files are in $(BUILDDIR)/text."

130+

131+man:

132+ $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man

133+ @echo

134+ @echo "Build finished. The manual pages are in $(BUILDDIR)/man."

135+

136+texinfo:

137+ $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo

138+ @echo

139+ @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."

140+ @echo "Run \`make' in that directory to run these through makeinfo" \

141+ "(use \`make info' here to do that automatically)."

142+

143+info:

144+ $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo

145+ @echo "Running Texinfo files through makeinfo..."

146+ make -C $(BUILDDIR)/texinfo info

147+ @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."

148+

149+gettext:

150+ $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale

151+ @echo

152+ @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."

153+

154+changes:

155+ $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes

156+ @echo

157+ @echo "The overview file is in $(BUILDDIR)/changes."

158+

159+linkcheck:

160+ $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck

161+ @echo

162+ @echo "Link check complete; look for any errors in the above output " \

163+ "or in $(BUILDDIR)/linkcheck/output.txt."

164+

165+doctest:

166+ $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest

167+ @echo "Testing of doctests in the sources finished, look at the " \

168+ "results in $(BUILDDIR)/doctest/output.txt."

169+

170+coverage:

171+ $(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage

172+ @echo "Testing of coverage in the sources finished, look at the " \

173+ "results in $(BUILDDIR)/coverage/python.txt."

174+

175+xml:

176+ $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml

177+ @echo

178+ @echo "Build finished. The XML files are in $(BUILDDIR)/xml."

179+

180+pseudoxml:

181+ $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml

182+ @echo

183+ @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."

docs/README.mdnew file+51

@@ -0,0 +1,51 @@

1+# Documentation for the Idris Language.

2+

3+

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).

5+

6+## Dependencies

7+

8+To build the manual the following dependencies must be met. We assume that you have standard build automation tools already install i.e. `make`.

9+

10+### Sphinx-Doc

11+

12+Python should be installed by default on most systems.

13+Sphinx can be installed either through your hosts package manager or using pip/easy_install.

14+

15+*Note* [ReadTheDocs](https://www.readthedocs.org) works with Sphinx

16+ `v1.2.2`. If you install a more recent version of sphinx then

17+ 'incorrectly' marked up documentation may get passed the build system

18+ of readthedocs and be ignored. In the past we had several code-blocks

19+ disappear because of that.

20+

21+The ReadTheDocs theme can be installed using pip as follows:

22+

23+```sh

24+pip install sphinx_rtd_theme

25+```

26+

27+### LaTeX

28+

29+LaTeX can be install either using your systems package manager or direct from TeXLive.

30+

31+

32+## Build Instructions

33+

34+```sh

35+make html

36+make latexpdf

37+```

38+

39+## Contributing

40+

41+The documentation for Idris has been published under the Creative

42+Commons CC0 License. As such to the extent possible under law, /The

43+Idris Community/ has waived all copyright and related or neighboring

44+rights to Documentation for Idris.

45+

46+More information concerning the CC0 can be found online at:

47+

48+ https://creativecommons.org/publicdomain/zero/1.0/

49+

50+

51+When contributing material to the manual please bear in mind that the work will be licensed as above.

docs/_static/theme_overrides.cssnew file+13

@@ -0,0 +1,13 @@

1+/* override table width restrictions */

2+@media screen and (min-width: 767px) {

3+

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;

8+ }

9+

10+ .wy-table-responsive {

11+ overflow: visible !important;

12+ }

13+}

docs/conf.pynew file+437

@@ -0,0 +1,437 @@

1+# -*- coding: utf-8 -*-

2+#

3+# Idris Manual documentation build configuration file, created by

4+# sphinx-quickstart on Sat Feb 28 20:41:47 2015.

5+#

6+# This file is execfile()d with the current directory set to its

7+# containing dir.

8+#

9+# Note that not all possible configuration values are present in this

10+# autogenerated file.

11+#

12+# All configuration values have a default; values that are commented out

13+# serve to show the default.

14+

15+import sys

16+import os

17+

18+# True if the readthedocs theme is locally installed

19+on_rtd = os.environ.get('READTHEDOCS', None) == 'True'

20+

21+# If extensions (or modules to document with autodoc) are in another directory,

22+# add these directories to sys.path here. If the directory is relative to the

23+# documentation root, use os.path.abspath to make it absolute, like shown here.

24+#sys.path.insert(0, os.path.abspath('.'))

25+

26+# -- General configuration ------------------------------------------------

27+

28+# If your documentation needs a minimal Sphinx version, state it here.

29+#needs_sphinx = '1.0'

30+

31+# Add any Sphinx extension module names here, as strings. They can be

32+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom

33+# ones.

34+extensions = [

35+ 'sphinx.ext.todo',

36+# 'sphinx.ext.pngmath', # imgmath is not supported on readthedocs.

37+ 'sphinx.ext.ifconfig',

38+]

39+

40+# Add any paths that contain templates here, relative to this directory.

41+templates_path = ['_templates']

42+

43+# The suffix of source filenames.

44+source_suffix = '.rst'

45+

46+# The encoding of source files.

47+#source_encoding = 'utf-8-sig'

48+

49+# The master toctree document.

50+master_doc = 'index'

51+

52+# General information about the project.

53+project = u'Idris'

54+copyright = u'2017-2020, The Idris Community'

55+author = u'The Idris Community'

56+

57+# The version info for the project you're documenting, acts as replacement for

58+# |version| and |release|, also used in various other places throughout the

59+# built documents.

60+#

61+# The short X.Y version.

62+version = '1.3'

63+# The full version, including alpha/beta/rc tags.

64+release = '1.3.2'

65+

66+# The language for content autogenerated by Sphinx. Refer to documentation

67+# for a list of supported languages.

68+#

69+# This is also used if you do content translation via gettext catalogs.

70+# Usually you set "language" from the command line for these cases.

71+language = None

72+

73+# There are two options for replacing |today|: either, you set today to some

74+# non-false value, then it is used:

75+#today = ''

76+# Else, today_fmt is used as the format for a strftime call.

77+#today_fmt = '%B %d, %Y'

78+

79+# List of patterns, relative to source directory, that match files and

80+# directories to ignore when looking for source files.

81+exclude_patterns = ['_build']

82+

83+# The reST default role (used for this markup: `text`) to use for all

84+# documents.

85+#default_role = None

86+

87+# If true, '()' will be appended to :func: etc. cross-reference text.

88+#add_function_parentheses = True

89+

90+# If true, the current module name will be prepended to all description

91+# unit titles (such as .. function::).

92+#add_module_names = True

93+

94+# If true, sectionauthor and moduleauthor directives will be shown in the

95+# output. They are ignored by default.

96+#show_authors = False

97+

98+# The name of the Pygments (syntax highlighting) style to use.

99+pygments_style = 'sphinx'

100+

101+# A list of ignored prefixes for module index sorting.

102+#modindex_common_prefix = []

103+

104+# If true, keep warnings as "system message" paragraphs in the built documents.

105+#keep_warnings = False

106+

107+# If true, `todo` and `todoList` produce output, else they produce nothing.

108+todo_include_todos = True

109+

110+

111+# -- Options for HTML output ----------------------------------------------

112+

113+# The theme to use for HTML and HTML Help pages. See the documentation for

114+# a list of builtin themes.

115+html_theme = "default"

116+

117+if not on_rtd: # only import and set the theme if we're building docs locally

118+ try:

119+ import sphinx_rtd_theme

120+ html_theme = 'sphinx_rtd_theme'

121+ html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]

122+ except ImportError:

123+ html_theme = "default"

124+

125+# Theme options are theme-specific and customize the look and feel of a theme

126+# further. For a list of options available for each theme, see the

127+# documentation.

128+#html_theme_options = {}

129+

130+# Add any paths that contain custom themes here, relative to this directory.

131+#html_theme_path = []

132+

133+# The name for this set of Sphinx documents. If None, it defaults to

134+# "<project> v<release> documentation".

135+#html_title = None

136+

137+# A shorter title for the navigation bar. Default is the same as html_title.

138+#html_short_title = None

139+

140+# The name of an image file (relative to this directory) to place at the top

141+# of the sidebar.

142+#html_logo = None

143+

144+# The name of an image file (within the static path) to use as favicon of the

145+# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32

146+# pixels large.

147+#html_favicon = None

148+

149+# Add any paths that contain custom static files (such as style sheets) here,

150+# relative to this directory. They are copied after the builtin static files,

151+# so a file named "default.css" will overwrite the builtin "default.css".

152+html_static_path = ['_static']

153+

154+html_context = {

155+ 'css_files': [

156+ '_static/theme_overrides.css', # override wide tables in RTD theme

157+ ],

158+ }

159+

160+# Add any extra paths that contain custom files (such as robots.txt or

161+# .htaccess) here, relative to this directory. These files are copied

162+# directly to the root of the documentation.

163+#html_extra_path = []

164+

165+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,

166+# using the given strftime format.

167+#html_last_updated_fmt = '%b %d, %Y'

168+

169+# If true, SmartyPants will be used to convert quotes and dashes to

170+# typographically correct entities.

171+#html_use_smartypants = True

172+

173+# Custom sidebar templates, maps document names to template names.

174+#html_sidebars = {}

175+

176+# Additional templates that should be rendered to pages, maps page names to

177+# template names.

178+#html_additional_pages = {}

179+

180+# If false, no module index is generated.

181+#html_domain_indices = True

182+

183+# If false, no index is generated.

184+#html_use_index = True

185+

186+# If true, the index is split into individual pages for each letter.

187+#html_split_index = False

188+

189+# If true, links to the reST sources are added to the pages.

190+#html_show_sourcelink = True

191+

192+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.

193+#html_show_sphinx = True

194+

195+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.

196+#html_show_copyright = True

197+

198+# If true, an OpenSearch description file will be output, and all pages will

199+# contain a <link> tag referring to it. The value of this option must be the

200+# base URL from which the finished HTML is served.

201+#html_use_opensearch = ''

202+

203+# This is the file name suffix for HTML files (e.g. ".xhtml").

204+#html_file_suffix = None

205+

206+# Language to be used for generating the HTML full-text search index.

207+# Sphinx supports the following languages:

208+# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'

209+# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'

210+#html_search_language = 'en'

211+

212+# A dictionary with options for the search language support, empty by default.

213+# Now only 'ja' uses this config value

214+#html_search_options = {'type': 'default'}

215+

216+# The name of a javascript file (relative to the configuration directory) that

217+# implements a search results scorer. If empty, the default will be used.

218+#html_search_scorer = 'scorer.js'

219+

220+# Output file base name for HTML help builder.

221+htmlhelp_basename = 'IdrisManualdoc'

222+

223+# -- Options for LaTeX output ---------------------------------------------

224+

225+latex_title_page = r'''

226+\begin{titlepage}

227+ \vspace*{\fill}

228+ \begin{center}

229+ \includegraphics[width=0.25\textwidth]{idris-512x512.png}\par

230+ \vspace{1cm}

231+ {\huge\sffamily\bfseries \makeatletter\@title\makeatother\par}

232+ \vspace{1cm}

233+ {\Large Version \version\par}

234+ \end{center}

235+ \vspace*{\fill}

236+\end{titlepage}

237+'''

238+

239+latex_elements = {

240+# The paper size ('letterpaper' or 'a4paper').

241+'papersize': 'a4paper',

242+

243+'fontpkg': '',

244+'inputenc': '',

245+'utf8extra': '',

246+'releasename': 'Version',

247+

248+# The font size ('10pt', '11pt' or '12pt').

249+'pointsize': '10pt',

250+

251+# Additional stuff for the LaTeX preamble.

252+'preamble': r'''

253+\usepackage{lmodern}

254+\usepackage{textalpha}

255+\usepackage[T1]{fontenc}

256+\usepackage[utf8x]{inputenc}

257+\usepackage{titlesec}

258+%

259+\usepackage{fancyhdr}

260+\fancypagestyle{plain}{%

261+ \renewcommand{\headrulewidth}{0pt}%

262+ \fancyhf{}%

263+ \fancyfoot[C]{\textsf{\thepage}}

264+}

265+\pagestyle{fancy}

266+\fancyhf{}

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}

276+%

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}

289+%

290+\hypersetup{colorlinks = false}

291+\definecolor{VerbatimBorderColor}{rgb}{1,1,1}

292+''',

293+

294+'maketitle': latex_title_page,

295+'tableofcontents': "\\tableofcontents"

296+# Latex figure (float) alignment

297+#'figure_align': 'htbp',

298+}

299+

300+# Grouping the document tree into LaTeX files. List of tuples

301+# (source start file, target name, title,

302+# author, documentclass [howto, manual, or own class]).

303+latex_documents = [

304+ # (master_doc, 'idris.tex', u'Documentation for the Idris Language', u'The Idris Community', 'report')

305+ ('tutorial/index', 'idris-tutorial.tex', u'The Idris Tutorial', u'The Idris Community', 'howto'),

306+]

307+

308+

309+latex_show_pagerefs = True

310+latex_show_url = 'footnote'

311+

312+# The name of an image file (relative to this directory) to place at the top of

313+# the title page.

314+latex_logo = '../icons/idris-512x512.png'

315+

316+# For "manual" documents, if this is true, then toplevel headings are parts,

317+# not chapters.

318+#latex_use_parts = True

319+

320+# If true, show page references after internal links.

321+#latex_show_pagerefs = False

322+

323+# If true, show URL addresses after external links.

324+#latex_show_urls = False

325+

326+# Documents to append as an appendix to all manuals.

327+#latex_appendices = []

328+

329+# If false, no module index is generated.

330+#latex_domain_indices = True

331+

332+

333+# -- Options for manual page output ---------------------------------------

334+

335+# One entry per manual page. List of tuples

336+# (source start file, name, description, authors, manual section).

337+man_pages = [

338+ (master_doc, 'idrismanual', u'Idris Manual Documentation',

339+ [author], 1)

340+]

341+

342+# If true, show URL addresses after external links.

343+#man_show_urls = False

344+

345+

346+# -- Options for Texinfo output -------------------------------------------

347+

348+# Grouping the document tree into Texinfo files. List of tuples

349+# (source start file, target name, title, author,

350+# dir menu entry, description, category)

351+texinfo_documents = [

352+ (master_doc, 'IdrisManual', u'Idris Manual Documentation',

353+ author, 'IdrisManual', 'One line description of project.',

354+ 'Miscellaneous'),

355+]

356+

357+# Documents to append as an appendix to all manuals.

358+#texinfo_appendices = []

359+

360+# If false, no module index is generated.

361+#texinfo_domain_indices = True

362+

363+# How to display URL addresses: 'footnote', 'no', or 'inline'.

364+#texinfo_show_urls = 'footnote'

365+

366+# If true, do not generate a @detailmenu in the "Top" node's menu.

367+#texinfo_no_detailmenu = False

368+

369+

370+# -- Options for Epub output ----------------------------------------------

371+

372+# Bibliographic Dublin Core info.

373+epub_title = project

374+epub_author = author

375+epub_publisher = author

376+epub_copyright = copyright

377+

378+# The basename for the epub file. It defaults to the project name.

379+#epub_basename = project

380+

381+# The HTML theme for the epub output. Since the default themes are not optimized

382+# for small screen space, using the same theme for HTML and epub output is

383+# usually not wise. This defaults to 'epub', a theme designed to save visual

384+# space.

385+#epub_theme = 'epub'

386+

387+# The language of the text. It defaults to the language option

388+# or 'en' if the language is not set.

389+#epub_language = ''

390+

391+# The scheme of the identifier. Typical schemes are ISBN or URL.

392+#epub_scheme = ''

393+

394+# The unique identifier of the text. This can be a ISBN number

395+# or the project homepage.

396+#epub_identifier = ''

397+

398+# A unique identification for the text.

399+#epub_uid = ''

400+

401+# A tuple containing the cover image and cover page html template filenames.

402+#epub_cover = ()

403+

404+# A sequence of (type, uri, title) tuples for the guide element of content.opf.

405+#epub_guide = ()

406+

407+# HTML files that should be inserted before the pages created by sphinx.

408+# The format is a list of tuples containing the path and title.

409+#epub_pre_files = []

410+

411+# HTML files shat should be inserted after the pages created by sphinx.

412+# The format is a list of tuples containing the path and title.

413+#epub_post_files = []

414+

415+# A list of files that should not be packed into the epub file.

416+epub_exclude_files = ['search.html']

417+

418+# The depth of the table of contents in toc.ncx.

419+#epub_tocdepth = 3

420+

421+# Allow duplicate toc entries.

422+#epub_tocdup = True

423+

424+# Choose between 'default' and 'includehidden'.

425+#epub_tocscope = 'default'

426+

427+# Fix unsupported image types using the Pillow.

428+#epub_fix_images = False

429+

430+# Scale large images.

431+#epub_max_image_width = 0

432+

433+# How to display URL addresses: 'footnote', 'no', or 'inline'.

434+#epub_show_urls = 'inline'

435+

436+# If false, no index is generated.

437+#epub_use_index = True

docs/effects/conclusions.rstnew file+76

@@ -0,0 +1,76 @@

1+.. _sect-further:

2+

3+***************

4+Further Reading

5+***************

6+

7+This tutorial has given an introduction to writing and reasoning about

8+side-effecting programs in Idris, using the ``Effects`` library.

9+More details about the *implementation* of the library, such as how

10+``run`` works, how handlers are invoked, etc, are given in a separate

11+paper [1]_.

12+

13+Some libraries and programs which use ``Effects`` can be found in the

14+following places:

15+

16+- https://github.com/edwinb/SDL-idris — some bindings for the SDL media

17+ library, supporting graphics in particular.

18+

19+- https://github.com/edwinb/idris-demos — various demonstration

20+ programs, including several examples from this tutorial, and a “Space

21+ Invaders” game.

22+

23+- https://github.com/SimonJF/IdrisNet2 — networking and socket

24+ libraries.

25+

26+- https://github.com/edwinb/Protocols — a high level communication

27+ protocol description language.

28+

29+The inspiration for the ``Effects`` library was Bauer and Pretnar’s

30+Eff language [2]_, which describes a language based on algebraic

31+effects and handlers. Other recent languages and libraries have also

32+been built on this ideas, for example [3]_ and [4]_. The theoretical

33+foundations are also well-studied see [5]_, [6]_, [7]_, [8]_.

34+

35+

36+

37+.. [1] Edwin Brady. 2013. Programming and reasoning with algebraic

38+ effects and dependent types. SIGPLAN Not. 48, 9 (September

39+ 2013), 133-144. DOI=10.1145/2544174.2500581

40+ https://dl.acm.org/citation.cfm?doid=2544174.2500581

41+

42+.. [2] Andrej Bauer, Matija Pretnar, Programming with algebraic

43+ effects and handlers, Journal of Logical and Algebraic Methods

44+ in Programming, Volume 84, Issue 1, January 2015, Pages

45+ 108-123, ISSN 2352-2208,

46+ http://math.andrej.com/wp-content/uploads/2012/03/eff.pdf

47+

48+

49+.. [3] Ben Lippmeier. 2009. Witnessing Purity, Constancy and

50+ Mutability. In Proceedings of the 7th Asian Symposium on

51+ Programming Languages and Systems (APLAS '09), Zhenjiang Hu

52+ (Ed.). Springer-Verlag, Berlin, Heidelberg,

53+ 95-110. DOI=10.1007/978-3-642-10672-9_9

54+ https://link.springer.com/chapter/10.1007%2F978-3-642-10672-9_9

55+

56+

57+.. [4] Ohad Kammar, Sam Lindley, and Nicolas Oury. 2013. Handlers in

58+ action. SIGPLAN Not. 48, 9 (September 2013),

59+ 145-158. DOI=10.1145/2544174.2500590

60+ https://dl.acm.org/citation.cfm?doid=2544174.2500590

61+

62+.. [5] Martin Hyland, Gordon Plotkin, John Power, Combining effects:

63+ Sum and tensor, Theoretical Computer Science, Volume 357,

64+ Issues 1–3, 25 July 2006, Pages 70-99, ISSN 0304-3975,

65+ (https://www.sciencedirect.com/science/article/pii/S0304397506002659)

66+

67+.. [6] Paul Blain Levy. 2004. Call-By-Push-Value: A

68+ Functional/Imperative Synthesis (Semantics Structures in

69+ Computation, V. 2). Kluwer Academic Publishers, Norwell, MA,

70+ USA.

71+

72+.. [7] Plotkin, Gordon, and Matija Pretnar. "Handlers of algebraic

73+ effects." Programming Languages and Systems. Springer Berlin

74+ Heidelberg, 2009. 80-94.

75+

76+.. [8] Pretnar, Matija. "Logic and handling of algebraic effects." (2010).

docs/effects/depeff.rstnew file+342

@@ -0,0 +1,342 @@

1+.. _sect-depeff:

2+

3+*****************

4+Dependent Effects

5+*****************

6+

7+In the programs we have seen so far, the available effects have remained

8+constant. Sometimes, however, an operation can *change* the available

9+effects. The simplest example occurs when we have a state with a

10+dependent type—adding an element to a vector also changes its type, for

11+example, since its length is explicit in the type. In this section, we

12+will see how the library supports this. Firstly, we will see how states

13+with dependent types can be implemented. Secondly, we will see how the

14+effects can depend on the *result* of an effectful operation. Finally,

15+we will see how this can be used to implement a type-safe and

16+resource-safe protocol for file management.

17+

18+Dependent States

19+================

20+

21+Suppose we have a function which reads input from the console, converts

22+it to an integer, and adds it to a list which is stored in a ``STATE``.

23+It might look something like the following:

24+

25+.. code-block:: idris

26+

27+ readInt : Eff () [STATE (List Int), STDIO]

28+ readInt = do let x = trim !getStr

29+ put (cast x :: !get)

30+

31+But what if, instead of a list of integers, we would like to store a

32+``Vect``, maintaining the length in the type?

33+

34+.. code-block:: idris

35+

36+ readInt : Eff () [STATE (Vect n Int), STDIO]

37+ readInt = do let x = trim !getStr

38+ put (cast x :: !get)

39+

40+This will not type check! Although the vector has length ``n`` on entry

41+to ``readInt``, it has length ``S n`` on exit. The library allows us to

42+express this as follows:

43+

44+.. code-block:: idris

45+

46+ readInt : Eff () [STATE (Vect n Int), STDIO]

47+ [STATE (Vect (S n) Int), STDIO]

48+ readInt = do let x = trim !getStr

49+ putM (cast x :: !get)

50+

51+The type ``Eff a xs xs'`` means that the operation

52+begins with effects ``xs`` available, and ends with effects ``xs’``

53+available. We have used ``putM`` to update the state, where the ``M``

54+suffix indicates that the *type* is being updated as well as the value.

55+It has the following type:

56+

57+.. code-block:: idris

58+

59+ putM : y -> Eff () [STATE x] [STATE y]

60+

61+Result-dependent Effects

62+========================

63+

64+Often, whether a state is updated could depend on the success or

65+otherwise of an operation. In our ``readInt`` example, we might wish to

66+update the vector only if the input is a valid integer (i.e. all

67+digits). As a first attempt, we could try the following, returning a

68+``Bool`` which indicates success:

69+

70+.. code-block:: idris

71+

72+ readInt : Eff Bool [STATE (Vect n Int), STDIO]

73+ [STATE (Vect (S n) Int), STDIO]

74+ readInt = do let x = trim !getStr

75+ case all isDigit (unpack x) of

76+ False => pure False

77+ True => do putM (cast x :: !get)

78+ pure True

79+

80+Unfortunately, this will not type check because the vector does not get

81+extended in both branches of the ``case``!

82+

83+::

84+

85+ MutState.idr:18:19:When elaborating right hand side of Main.case

86+ block in readInt:

87+ Unifying n and S n would lead to infinite value

88+

89+Clearly, the size of the resulting vector depends on whether or not the

90+value read from the user was valid. We can express this in the type:

91+

92+.. code-block:: idris

93+

94+ readInt : Eff Bool [STATE (Vect n Int), STDIO]

95+ (\ok => if ok then [STATE (Vect (S n) Int), STDIO]

96+ else [STATE (Vect n Int), STDIO])

97+ readInt = do let x = trim !getStr

98+ case all isDigit (unpack x) of

99+ False => pureM False

100+ True => do putM (cast x :: !get)

101+ pureM True

102+

103+Using ``pureM`` rather than ``pure`` allows the output effects to be

104+calculated from the value given. Its type is:

105+

106+.. code-block:: idris

107+

108+ pureM : (val : a) -> EffM m a (xs val) xs

109+

110+When using ``readInt``, we will have to check its return

111+value in order to know what the new set of effects is. For example, to

112+read a set number of values into a vector, we could write the following:

113+

114+.. code-block:: idris

115+

116+ readN : (n : Nat) ->

117+ Eff () [STATE (Vect m Int), STDIO]

118+ [STATE (Vect (n + m) Int), STDIO]

119+ readN Z = pure ()

120+ readN {m} (S k) = case !readInt of

121+ True => rewrite plusSuccRightSucc k m in readN k

122+ False => readN (S k)

123+

124+The ``case`` analysis on the result of ``readInt`` means that we know in

125+each branch whether reading the integer succeeded, and therefore how

126+many values still need to be read into the vector. What this means in

127+practice is that the type system has verified that a necessary dynamic

128+check (i.e. whether reading a value succeeded) has indeed been done.

129+

130+.. note::

131+ Only ``case`` will work here. We cannot use ``if/then/else``

132+ because the ``then`` and ``else`` branches must have the same

133+ type. The ``case`` construct, however, abstracts over the value

134+ being inspected in the type of each branch.

135+

136+File Management

137+===============

138+

139+A practical use for dependent effects is in specifying resource usage

140+protocols and verifying that they are executed correctly. For example,

141+file management follows a resource usage protocol with the following

142+(informally specified) requirements:

143+

144+- It is necessary to open a file for reading before reading it

145+

146+- Opening may fail, so the programmer should check whether opening was

147+ successful

148+

149+- A file which is open for reading must not be written to, and vice

150+ versa

151+

152+- When finished, an open file handle should be closed

153+

154+- When a file is closed, its handle should no longer be used

155+

156+These requirements can be expressed formally by creating a

157+``FILE_IO`` effect parameterised over a file handle state, which is

158+either empty, open for reading, or open for writing. The ``FILE_IO``

159+effect’s definition is given below.

160+

161+.. note::

162+ This effect is mainly for illustrative purposes.

163+ Typically we would also like to support random access files and

164+ better reporting of error conditions.

165+

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.

171+

172+.. code-block:: idris

173+

174+ module Effect.File

175+

176+ import Effects

177+ import Control.IOExcept

178+

179+ FILE_IO : Type -> EFFECT

180+

181+ data OpenFile : Mode -> Type

182+

183+ open : (fname : String)

184+ -> (m : Mode)

185+ -> Eff Bool [FILE_IO ()]

186+ (\res => [FILE_IO (case res of

187+ True => OpenFile m

188+ False => ())])

189+ close : Eff () [FILE_IO (OpenFile m)] [FILE_IO ()]

190+

191+ readLine : Eff String [FILE_IO (OpenFile Read)]

192+ writeLine : String -> Eff () [FILE_IO (OpenFile Write)]

193+ eof : Eff Bool [FILE_IO (OpenFile Read)]

194+

195+ Handler FileIO IO where { ... }

196+

197+In particular, consider the type of ``open``:

198+

199+.. code-block:: idris

200+

201+ open : (fname : String)

202+ -> (m : Mode)

203+ -> Eff Bool [FILE_IO ()]

204+ (\res => [FILE_IO (case res of

205+ True => OpenFile m

206+ False => ())])

207+

208+This returns a ``Bool`` which indicates whether opening the file was

209+successful. The resulting state depends on whether the operation was

210+successful; if so, we have a file handle open for the stated purpose,

211+and if not, we have no file handle. By ``case`` analysis on the result,

212+we continue the protocol accordingly.

213+

214+.. _eff-readfile:

215+.. code-block:: idris

216+

217+ readFile : Eff (List String) [FILE_IO (OpenFile Read)]

218+ readFile = readAcc [] where

219+ readAcc : List String -> Eff (List String) [FILE_IO (OpenFile Read)]

220+ readAcc acc = if (not !eof)

221+ then readAcc (!readLine :: acc)

222+ else pure (reverse acc)

223+

224+Given a function ``readFile``, above, which reads from

225+an open file until reaching the end, we can write a program which opens

226+a file, reads it, then displays the contents and closes it, as follows,

227+correctly following the protocol:

228+

229+.. code-block:: idris

230+

231+ dumpFile : String -> Eff () [FILE_IO (), STDIO]

232+ dumpFile name = case !(open name Read) of

233+ True => do putStrLn (show !readFile)

234+ close

235+ False => putStrLn ("Error!")

236+

237+The type of ``dumpFile``, with ``FILE_IO ()`` in its effect list,

238+indicates that any use of the file resource will follow the protocol

239+correctly (i.e. it both begins and ends with an empty resource). If we

240+fail to follow the protocol correctly (perhaps by forgetting to close

241+the file, failing to check that ``open`` succeeded, or opening the file

242+for writing) then we will get a compile-time error. For example,

243+changing ``open name Read`` to ``open name Write`` yields a compile-time

244+error of the following form:

245+

246+::

247+

248+ FileTest.idr:16:18:When elaborating right hand side of Main.case

249+ block in testFile:

250+ Can't solve goal

251+ SubList [(FILE_IO (OpenFile Read))]

252+ [(FILE_IO (OpenFile Write)), STDIO]

253+

254+In other words: when reading a file, we need a file which is open for

255+reading, but the effect list contains a ``FILE_IO`` effect carrying a

256+file open for writing.

257+

258+Pattern-matching bind

259+=====================

260+

261+It might seem that having to test each potentially failing operation

262+with a ``case`` clause could lead to ugly code, with lots of

263+nested case blocks. Many languages support exceptions to improve this,

264+but unfortunately exceptions may not allow completely clean resource

265+management—for example, guaranteeing that any ``open`` which did succeed

266+has a corresponding close.

267+

268+Idris supports *pattern-matching* bindings, such as the following:

269+

270+.. code-block:: idris

271+

272+ dumpFile : String -> Eff () [FILE_IO (), STDIO]

273+ dumpFile name = do True <- open name Read

274+ putStrLn (show !readFile)

275+ close

276+

277+This also has a problem: we are no longer dealing with the case where

278+opening a file failed! The solution is to extend the pattern-matching

279+binding syntax to give brief clauses for failing matches. Here, for

280+example, we could write:

281+

282+.. code-block:: idris

283+

284+ dumpFile : String -> Eff () [FILE_IO (), STDIO]

285+ dumpFile name = do True <- open name Read | False => putStrLn "Error"

286+ putStrLn (show !readFile)

287+ close

288+

289+This is exactly equivalent to the definition with the explicit ``case``.

290+In general, in a ``do``-block, the syntax:

291+

292+.. code-block:: idris

293+

294+ do pat <- val | <alternatives>

295+ p

296+

297+is desugared to

298+

299+.. code-block:: idris

300+

301+ do x <- val

302+ case x of

303+ pat => p

304+ <alternatives>

305+

306+There can be several ``alternatives``, separated by a vertical bar

307+``|``. For example, there is a ``SYSTEM`` effect which supports

308+reading command line arguments, among other things (see Appendix

309+:ref:`sect-appendix`). To read command line arguments, we can use

310+``getArgs``:

311+

312+.. code-block:: idris

313+

314+ getArgs : Eff (List String) [SYSTEM]

315+

316+A main program can read command line arguments as follows, where in the

317+list which is returned, the first element ``prog`` is the executable

318+name and the second is an expected argument:

319+

320+.. code-block:: idris

321+

322+ emain : Eff () [SYSTEM, STDIO]

323+ emain = do [prog, arg] <- getArgs

324+ putStrLn $ "Argument is " ++ arg

325+ {- ... rest of function ... -}

326+

327+Unfortunately, this will not fail gracefully if no argument is given, or

328+if too many arguments are given. We can use pattern matching bind

329+alternatives to give a better (more informative) error:

330+

331+.. code-block:: idris

332+

333+ emain : Eff () [SYSTEM, STDIO]

334+ emain = do [prog, arg] <- getArgs | [] => putStrLn "Can't happen!"

335+ | [prog] => putStrLn "No arguments!"

336+ | _ => putStrLn "Too many arguments!"

337+ putStrLn $ "Argument is " ++ arg

338+ {- ... rest of function ... -}

339+

340+If ``getArgs`` does not return something of the form ``[prog, arg]`` the

341+alternative which does match is executed instead, and that value

342+returned.

docs/effects/hangman.rstnew file+329

@@ -0,0 +1,329 @@

1+.. _sect-hangman:

2+

3+***************************************

4+Example: A “Mystery Word” Guessing Game

5+***************************************

6+

7+In this section, we will use the techniques and specific effects

8+discussed in the tutorial so far to implement a larger example, a simple

9+text-based word-guessing game. In the game, the computer chooses a word,

10+which the player must guess letter by letter. After a limited number of

11+wrong guesses, the player loses [1]_.

12+

13+We will implement the game by following these steps:

14+

15+#. Define the game state, in enough detail to express the rules

16+

17+#. Define the rules of the game (i.e. what actions the player may take,

18+ and how these actions affect the game state)

19+

20+#. Implement the rules of the game (i.e. implement state updates for

21+ each action)

22+

23+#. Implement a user interface which allows a player to direct actions

24+

25+Step 2 may be achieved by defining an effect which depends on the state

26+defined in step 1. Then step 3 involves implementing a ``Handler`` for

27+this effect. Finally, step 4 involves implementing a program in ``Eff``

28+using the newly defined effect (and any others required to implement the

29+interface).

30+

31+Step 1: Game State

32+==================

33+

34+First, we categorise the game states as running games (where there are a

35+number of guesses available, and a number of letters still to guess), or

36+non-running games (i.e. games which have not been started, or games

37+which have been won or lost).

38+

39+.. code-block:: idris

40+

41+ data GState = Running Nat Nat | NotRunning

42+

43+Notice that at this stage, we say nothing about what it means to make a

44+guess, what the word to be guessed is, how to guess letters, or any

45+other implementation detail. We are only interested in what is necessary

46+to describe the game rules.

47+

48+We will, however, parameterise a concrete game state ``Mystery`` over

49+this data:

50+

51+.. code-block:: idris

52+

53+ data Mystery : GState -> Type

54+

55+Step 2: Game Rules

56+==================

57+

58+We describe the game rules as a dependent effect, where each action has

59+a *precondition* (i.e. what the game state must be before carrying out

60+the action) and a *postcondition* (i.e. how the action affects the game

61+state). Informally, these actions with the pre- and postconditions are:

62+

63+Guess

64+ Guess a letter in the word.

65+

66+ - Precondition: The game must be running, and there must be both

67+ guesses still available, and letters still to be guessed.

68+

69+ - Postcondition: If the guessed letter is in the word and not yet

70+ guessed, reduce the number of letters, otherwise reduce the

71+ number of guesses.

72+

73+Won

74+ Declare victory

75+

76+ - Precondition: The game must be running, and there must be no

77+ letters still to be guessed.

78+

79+ - Postcondition: The game is no longer running.

80+

81+Lost

82+ Accept defeat

83+

84+ - Precondition: The game must be running, and there must be no

85+ guesses left.

86+

87+ - Postcondition: The game is no longer running.

88+

89+NewWord

90+ Set a new word to be guessed

91+

92+ - Precondition: The game must not be running.

93+

94+ - Postcondition: The game is running, with 6 guesses available (the

95+ choice of 6 is somewhat arbitrary here) and the number of unique

96+ letters in the word still to be guessed.

97+

98+Get

99+ Get a string representation of the game state. This is for display

100+ purposes; there are no pre- or postconditions.

101+

102+We can make these rules precise by declaring them more formally in an

103+effect signature:

104+

105+.. code-block:: idris

106+

107+ data MysteryRules : Effect where

108+ Guess : (x : Char) ->

109+ sig MysteryRules Bool

110+ (Mystery (Running (S g) (S w)))

111+ (\inword => if inword

112+ then Mystery (Running (S g) w)

113+ else Mystery (Running g (S w)))

114+ Won : sig MysteryRules () (Mystery (Running g 0))

115+ (Mystery NotRunning)

116+ Lost : sig MysteryRules () (Mystery (Running 0 g))

117+ (Mystery NotRunning)

118+ NewWord : (w : String) ->

119+ sig MysteryRules () (Mystery NotRunning) (Mystery (Running 6 (length (letters w))))

120+ Get : sig MysteryRules String (Mystery h)

121+

122+This description says nothing about how the rules are implemented. In

123+particular, it does not specify *how* to tell whether a guessed letter

124+was in a word, just that the result of ``Guess`` depends on it.

125+

126+Nevertheless, we can still create an ``EFFECT`` from this, and use it in

127+an ``Eff`` program. Implementing a ``Handler`` for ``MysteryRules`` will

128+then allow us to play the game.

129+

130+.. code-block:: idris

131+

132+ MYSTERY : GState -> EFFECT

133+ MYSTERY h = MkEff (Mystery h) MysteryRules

134+

135+Step 3: Implement Rules

136+=======================

137+

138+To *implement* the rules, we begin by giving a concrete definition of

139+game state:

140+

141+.. code-block:: idris

142+

143+ data Mystery : GState -> Type where

144+ Init : Mystery NotRunning

145+ GameWon : (word : String) -> Mystery NotRunning

146+ GameLost : (word : String) -> Mystery NotRunning

147+ MkG : (word : String) ->

148+ (guesses : Nat) ->

149+ (got : List Char) ->

150+ (missing : Vect m Char) ->

151+ Mystery (Running guesses m)

152+

153+If a game is ``NotRunning``, that is either because it has not yet

154+started (``Init``) or because it is won or lost (``GameWon`` and

155+``GameLost``, each of which carry the word so that showing the game

156+state will reveal the word to the player). Finally, ``MkG`` captures a

157+running game’s state, including the target word, the letters

158+successfully guessed, and the missing letters. Using a ``Vect`` for the

159+missing letters is convenient since its length is used in the type.

160+

161+To initialise the state, we implement the following functions:

162+``letters``, which returns a list of unique letters in a ``String``

163+(ignoring spaces) and ``initState`` which sets up an initial state

164+considered valid as a postcondition for ``NewWord``.

165+

166+.. code-block:: idris

167+

168+ letters : String -> List Char

169+ initState : (x : String) -> Mystery (Running 6 (length (letters x)))

170+

171+When checking if a guess is in the vector of missing letters, it is

172+convenient to return a *proof* that the guess is in the vector, using

173+``isElem`` below, rather than merely a ``Bool``:

174+

175+.. code-block:: idris

176+

177+ data IsElem : a -> Vect n a -> Type where

178+ First : IsElem x (x :: xs)

179+ Later : IsElem x xs -> IsElem x (y :: xs)

180+

181+ isElem : DecEq a => (x : a) -> (xs : Vect n a) -> Maybe (IsElem x xs)

182+

183+The reason for returning a proof is that we can use it to remove an

184+element from the correct position in a vector:

185+

186+.. code-block:: idris

187+

188+ shrink : (xs : Vect (S n) a) -> IsElem x xs -> Vect n a

189+

190+We leave the definitions of ``letters``, ``init``, ``isElem`` and

191+``shrink`` as exercises. Having implemented these, the ``Handler``

192+implementation for ``MysteryRules`` is surprisingly straightforward:

193+

194+.. code-block:: idris

195+

196+ Handler MysteryRules m where

197+ handle (MkG w g got []) Won k = k () (GameWon w)

198+ handle (MkG w Z got m) Lost k = k () (GameLost w)

199+

200+ handle st Get k = k (show st) st

201+ handle st (NewWord w) k = k () (initState w)

202+

203+ handle (MkG w (S g) got m) (Guess x) k =

204+ case isElem x m of

205+ Nothing => k False (MkG w _ got m)

206+ (Just p) => k True (MkG w _ (x :: got) (shrink m p))

207+

208+Each case simply involves directly updating the game state in a way

209+which is consistent with the declared rules. In particular, in

210+``Guess``, if the handler claims that the guessed letter is in the word

211+(by passing ``True`` to ``k``), there is no way to update the state in

212+such a way that the number of missing letters or number of guesses does

213+not follow the rules.

214+

215+Step 4: Implement Interface

216+===========================

217+

218+Having described the rules, and implemented state transitions which

219+follow those rules as an effect handler, we can now write an interface

220+for the game which uses the ``MYSTERY`` effect:

221+

222+.. code-block:: idris

223+

224+ game : Eff () [MYSTERY (Running (S g) w), STDIO]

225+ [MYSTERY NotRunning, STDIO]

226+

227+The type indicates that the game must start in a running state, with

228+some guesses available, and eventually reach a not-running state (i.e.

229+won or lost). The only way to achieve this is by correctly following the

230+stated rules.

231+

232+Note that the type of ``game`` makes no assumption that there are

233+letters to be guessed in the given word (i.e. it is ``w`` rather than

234+``S w``). This is because we will be choosing a word at random from a

235+vector of ``String``, and at no point have we made it explicit that

236+those ``String`` are non-empty.

237+

238+Finally, we need to initialise the game by picking a word at random from

239+a list of candidates, setting it as the target using ``NewWord``, then

240+running ``game``:

241+

242+.. code-block:: idris

243+

244+ runGame : Eff () [MYSTERY NotRunning, RND, SYSTEM, STDIO]

245+ runGame = do srand !time

246+ let w = index !(rndFin _) words

247+ call $ NewWord w

248+ game

249+ putStrLn !(call Get)

250+

251+We use the system time (``time`` from the ``SYSTEM`` effect; see

252+Appendix :ref:`sect-appendix`) to initialise the random number

253+generator, then pick a random ``Fin`` to index into a list of

254+``words``. For example, we could initialise a word list as follows:

255+

256+.. code-block:: idris

257+

258+ words : ?wtype

259+ words = with Vect ["idris","agda","haskell","miranda",

260+ "java","javascript","fortran","basic",

261+ "coffeescript","rust"]

262+

263+ wtype = proof search

264+

265+.. note::

266+ Rather than have to explicitly declare a type with the vector’s

267+ length, it is convenient to give a hole ``?wtype`` and let

268+ Idris’s proof search mechanism find the type. This is a

269+ limited form of type inference, but very useful in practice.

270+

271+A possible complete implementation of ``game`` is

272+presented below:

273+

274+.. code-block:: idris

275+

276+ game : Eff () [MYSTERY (Running (S g) w), STDIO]

277+ [MYSTERY NotRunning, STDIO]

278+ game {w=Z} = Won

279+ game {w=S _}

280+ = do putStrLn !Get

281+ putStr "Enter guess: "

282+ let guess = trim !getStr

283+ case choose (not (guess == "")) of

284+ (Left p) => processGuess (strHead' guess p)

285+ (Right p) => do putStrLn "Invalid input!"

286+ game

287+ where

288+ processGuess : Char -> Eff () [MYSTERY (Running (S g) (S w)), STDIO]

289+ [MYSTERY NotRunning, STDIO]

290+ processGuess {g} {w} c

291+ = case !(Main.Guess c) of

292+ True => do putStrLn "Good guess!"

293+ case w of

294+ Z => Won

295+ (S k) => game

296+ False => do putStrLn "No, sorry"

297+ case g of

298+ Z => Lost

299+ (S k) => game

300+

301+Discussion

302+==========

303+

304+Writing the rules separately as an effect, then an implementation

305+which uses that effect, ensures that the implementation must follow

306+the rules. This has practical applications in more serious contexts;

307+``MysteryRules`` for example can be though of as describing a

308+*protocol* that a game player most follow, or alternative a

309+*precisely-typed API*.

310+

311+In practice, we wouldn’t really expect to write rules first then

312+implement the game once the rules were complete. Indeed, I didn’t do

313+so when constructing this example! Rather, I wrote down a set of

314+likely rules making any assumptions *explicit* in the state

315+transitions for ``MysteryRules``. Then, when implementing ``game`` at

316+first, any incorrect assumption was caught as a type error. The

317+following errors were caught during development:

318+

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.

320+

321+- Forgetting to check whether a game was won before recursively calling ``processGuess``, thus accidentally continuing a finished game.

322+

323+- Accidentally checking the number of missing letters, rather than the number of remaining guesses, when checking if a game was lost.

324+

325+These are, of course, simple errors, but were caught by the type

326+checker before any testing of the game.

327+

328+.. [1]

329+ Readers may recognise this game by the name “Hangman”.

docs/effects/impleff.rstnew file+333

@@ -0,0 +1,333 @@

1+.. _sect-impleff:

2+

3+********************

4+Creating New Effects

5+********************

6+

7+We have now seen several side-effecting operations provided by the

8+``Effects`` library, and examples of their use in Section

9+:ref:`sect-simpleff`. We have also seen how operations may *modify*

10+the available effects by changing state in Section

11+:ref:`sect-depeff`. We have not, however, yet seen how these

12+operations are implemented. In this section, we describe how a

13+selection of the available effects are implemented, and show how new

14+effectful operations may be provided.

15+

16+State

17+=====

18+

19+Effects are described by *algebraic data types*, where the

20+constructors describe the operations provided when the effect is

21+available. Stateful operations are described as follows:

22+

23+.. code-block:: idris

24+

25+ data State : Effect where

26+ Get : State a a (\x => a)

27+ Put : b -> State () a (\x => b)

28+

29+``Effect`` itself is a type synonym, giving the required type for an

30+effect signature:

31+

32+.. code-block:: idris

33+

34+ Effect : Type

35+ Effect = (result : Type) ->

36+ (input_resource : Type) ->

37+ (output_resource : result -> Type) -> Type

38+

39+Each effect is associated with a *resource*. The second argument to

40+an effect signature is the resource type on *input* to an operation,

41+and the third is a function which computes the resource type on

42+*output*. Here, it means:

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``.

45+

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.

47+

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

51+write:

52+

53+.. code-block:: idris

54+

55+ data State : Effect where

56+ Get : sig State a a

57+ Put : b -> sig State () a b

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.

62+

63+.. code-block:: idris

64+

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

74+

75+In order to convert ``State`` (of type ``Effect``) into something

76+usable in an effects list, of type ``EFFECT``, we write the following:

77+

78+.. code-block:: idris

79+

80+ STATE : Type -> EFFECT

81+ STATE t = MkEff t State

82+

83+``MkEff`` constructs an ``EFFECT`` by taking the resource type (here,

84+the ``t`` which parameterises ``STATE``) and the effect signature

85+(here, ``State``). For reference, ``EFFECT`` is declared as follows:

86+

87+.. code-block:: idris

88+

89+ data EFFECT : Type where

90+ MkEff : Type -> Effect -> EFFECT

91+

92+Recall that to run an effectful program in ``Eff``, we use one of the

93+``run`` family of functions to run the program in a particular

94+computation context ``m``. For each effect, therefore, we must explain

95+how it is executed in a particular computation context for ``run`` to

96+work in that context. This is achieved with the following interface:

97+

98+.. code-block:: idris

99+

100+ interface Handler (e : Effect) (m : Type -> Type) where

101+ handle : resource -> (eff : e t resource resource') ->

102+ ((x : t) -> resource' x -> m a) -> m a

103+

104+We have already seen some implementation declarations in the effect

105+summaries in Section :ref:`sect-simpleff`. An implementation of ``Handler e

106+m`` means that the effect declared with signature ``e`` can be run in

107+computation context ``m``. The ``handle`` function takes:

108+

109+- The ``resource`` on input (so, the current value of the state for ``State``)

110+

111+- The effectful operation (either ``Get`` or ``Put x`` for ``State``)

112+

113+- A *continuation*, which we conventionally call ``k``, and should be passed the result value of the operation, and an updated resource.

114+

115+There are two reasons for taking a continuation here: firstly, this is

116+neater because there are multiple return values (a new resource and

117+the result of the operation); secondly, and more importantly, the

118+continuation can be called zero or more times.

119+

120+A ``Handler`` for ``State`` simply passes on the value of the state,

121+in the case of ``Get``, or passes on a new state, in the case of

122+``Put``. It is defined the same way for all computation contexts:

123+

124+.. code-block:: idris

125+

126+ Handler State m where

127+ handle st Get k = k st st

128+ handle st (Put n) k = k () n

129+

130+This gives enough information for ``Get`` and ``Put`` to be used

131+directly in ``Eff`` programs. It is tidy, however, to define top level

132+functions in ``Eff``, as follows:

133+

134+.. code-block:: idris

135+

136+ get : Eff x [STATE x]

137+ get = call Get

138+

139+ put : x -> Eff () [STATE x]

140+ put val = call (Put val)

141+

142+ putM : y -> Eff () [STATE x] [STATE y]

143+ putM val = call (Put val)

144+

145+**An implementation detail (aside):** The ``call`` function converts

146+an ``Effect`` to a function in ``Eff``, given a proof that the effect

147+is available. This proof can be constructed automatically, since

148+it is essentially an index into a statically known list of effects:

149+

150+.. code-block:: idris

151+

152+ call : {e : Effect} ->

153+ (eff : e t a b) -> {auto prf : EffElem e a xs} ->

154+ Eff t xs (\v => updateResTy v xs prf eff)

155+

156+This is the reason for the ``Can’t solve goal`` error when an effect

157+is not available: the implicit proof ``prf`` has not been solved

158+automatically because the required effect is not in the list of

159+effects ``xs``.

160+

161+Such details are not important for using the library, or even writing

162+new effects, however.

163+

164+Summary

165+-------

166+

167+The following listing summarises what is required to define the

168+``STATE`` effect:

169+

170+.. code-block:: idris

171+

172+ data State : Effect where

173+ Get : sig State a a

174+ Put : b -> sig State () a b

175+

176+ STATE : Type -> EFFECT

177+ STATE t = MkEff t State

178+

179+ Handler State m where

180+ handle st Get k = k st st

181+ handle st (Put n) k = k () n

182+

183+ get : Eff x [STATE x]

184+ get = call Get

185+

186+ put : x -> Eff () [STATE x]

187+ put val = call (Put val)

188+

189+ putM : y -> Eff () [STATE x] [STATE y]

190+ putM val = call (Put val)

191+

192+

193+Console I/O

194+===========

195+

196+Then listing below gives the definition of the ``STDIO``

197+effect, including handlers for ``IO`` and ``IOExcept``. We omit the

198+definition of the top level ``Eff`` functions, as this merely invoke

199+the effects ``PutStr``, ``GetStr``, ``PutCh`` and ``GetCh`` directly.

200+

201+Note that in this case, the resource is the unit type in every case,

202+since the handlers merely apply the ``IO`` equivalents of the effects

203+directly.

204+

205+.. _eff-stdiodef:

206+.. code-block:: idris

207+

208+ data StdIO : Effect where

209+ PutStr : String -> sig StdIO ()

210+ GetStr : sig StdIO String

211+ PutCh : Char -> sig StdIO ()

212+ GetCh : sig StdIO Char

213+

214+ Handler StdIO IO where

215+ handle () (PutStr s) k = do putStr s; k () ()

216+ handle () GetStr k = do x <- getLine; k x ()

217+ handle () (PutCh c) k = do putChar c; k () ()

218+ handle () GetCh k = do x <- getChar; k x ()

219+

220+ Handler StdIO (IOExcept a) where

221+ handle () (PutStr s) k = do ioe_lift $ putStr s; k () ()

222+ handle () GetStr k = do x <- ioe_lift $ getLine; k x ()

223+ handle () (PutCh c) k = do ioe_lift $ putChar c; k () ()

224+ handle () GetCh k = do x <- ioe_lift $ getChar; k x ()

225+

226+ STDIO : EFFECT

227+ STDIO = MkEff () StdIO

228+

229+Exceptions

230+==========

231+

232+The listing below gives the definition of the ``Exception``

233+effect, including two of its handlers for ``Maybe`` and ``List``. The

234+only operation provided is ``Raise``. The key point to note in the

235+definitions of these handlers is that the continuation ``k`` is not

236+used. Running ``Raise`` therefore means that computation stops with an

237+error.

238+

239+.. code-block:: idris

240+

241+ data Exception : Type -> Effect where

242+ Raise : a -> sig (Exception a) b

243+

244+ Handler (Exception a) Maybe where

245+ handle _ (Raise e) k = Nothing

246+

247+ Handler (Exception a) List where

248+ handle _ (Raise e) k = []

249+

250+ EXCEPTION : Type -> EFFECT

251+ EXCEPTION t = MkEff () (Exception t)

252+

253+

254+Non-determinism

255+===============

256+

257+The following listing gives the definition of the ``Select``

258+effect for writing non-deterministic programs, including a handler for

259+``List`` context which returns all possible successful values, and a

260+handler for ``Maybe`` context which returns the first successful

261+value.

262+

263+.. code-block:: idris

264+

265+ data Selection : Effect where

266+ Select : List a -> sig Selection a

267+

268+ Handler Selection Maybe where

269+ handle _ (Select xs) k = tryAll xs where

270+ tryAll [] = Nothing

271+ tryAll (x :: xs) = case k x () of

272+ Nothing => tryAll xs

273+ Just v => Just v

274+

275+ Handler Selection List where

276+ handle r (Select xs) k = concatMap (\x => k x r) xs

277+

278+ SELECT : EFFECT

279+ SELECT = MkEff () Selection

280+

281+

282+Here, the continuation is called multiple times in each handler, for

283+each value in the list of possible values. In the ``List`` handler, we

284+accumulate all successful results, and in the ``Maybe`` handler we try

285+the first value in the list, and try later values only if that fails.

286+

287+File Management

288+===============

289+

290+Result-dependent effects are no different from non-dependent effects

291+in the way they are implemented. The listing below

292+illustrates this for the ``FILE_IO`` effect. The syntax for state

293+transitions ``{ x ==> {res} x’ }``, where the result state ``x’`` is

294+computed from the result of the operation ``res``, follows that for

295+the equivalent ``Eff`` programs.

296+

297+.. code-block:: idris

298+

299+ data FileIO : Effect where

300+ Open : (fname: String)

301+ -> (m : Mode)

302+ -> sig FileIO Bool () (\res => case res of

303+ True => OpenFile m

304+ False => ())

305+ Close : sig FileIO () (OpenFile m)

306+

307+ ReadLine : sig FileIO String (OpenFile Read)

308+ WriteLine : String -> sig FileIO () (OpenFile Write)

309+ EOF : sig FileIO Bool (OpenFile Read)

310+

311+ Handler FileIO IO where

312+ handle () (Open fname m) k = do h <- openFile fname m

313+ if !(validFile h)

314+ then k True (FH h)

315+ else k False ()

316+ handle (FH h) Close k = do closeFile h

317+ k () ()

318+

319+ handle (FH h) ReadLine k = do str <- fread h

320+ k str (FH h)

321+ handle (FH h) (WriteLine str) k = do fwrite h str

322+ k () (FH h)

323+ handle (FH h) EOF k = do e <- feof h

324+ k e (FH h)

325+

326+ FILE_IO : Type -> EFFECT

327+ FILE_IO t = MkEff t FileIO

328+

329+Note that in the handler for ``Open``, the types passed to the

330+continuation ``k`` are different depending on whether the result is

331+``True`` (opening succeeded) or ``False`` (opening failed). This uses

332+``validFile``, defined in the ``Prelude``, to test whether a file

333+handler refers to an open file or not.

docs/effects/index.rstnew file+40

@@ -0,0 +1,40 @@

1+.. _eff-tutorial-index:

2+

3+####################

4+The Effects Tutorial

5+####################

6+

7+A tutorial on the `Effects` package in `Idris`.

8+

9+.. topic:: Effects and the ``Control.ST`` module

10+

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.

15+

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`).

20+

21+.. note::

22+

23+ The documentation for Idris has been published under the Creative

24+ Commons CC0 License. As such to the extent possible under law, *The

25+ Idris Community* has waived all copyright and related or neighbouring

26+ rights to Documentation for Idris.

27+

28+ More information concerning the CC0 can be found online at: https://creativecommons.org/publicdomain/zero/1.0/

29+

30+.. toctree::

31+ :maxdepth: 1

32+

33+ introduction

34+ state

35+ simpleeff

36+ depeff

37+ impleff

38+ hangman

39+ conclusions

40+ summary

docs/effects/introduction.rstnew file+110

@@ -0,0 +1,110 @@

1+************

2+Introduction

3+************

4+

5+Pure functional languages with dependent types such as `Idris

6+<https://www.idris-lang.org/>`_ support reasoning about programs directly

7+in the type system, promising that we can *know* a program will run

8+correctly (i.e. according to the specification in its type) simply

9+because it compiles. Realistically, though, things are not so simple:

10+programs have to interact with the outside world, with user input,

11+input from a network, mutable state, and so on. In this tutorial I

12+will introduce the library, which is included with the distribution

13+and supports programming and reasoning with side-effecting programs,

14+supporting mutable state, interaction with the outside world,

15+exceptions, and verified resource management.

16+

17+This tutorial assumes familiarity with pure programming in Idris,

18+as described in Sections 1–6 of the main tutorial [1]_. The examples

19+presented are tested with Idris and can be found in the

20+examples directory of the Idris repository. The ``-p effects`` flag

21+is needed when starting Idris.

22+

23+Consider, for example, the following introductory function which

24+illustrates the kind of properties which can be expressed in the type

25+system:

26+

27+.. code-block:: idris

28+

29+ vadd : Vect n Int -> Vect n Int -> Vect n Int

30+ vadd [] [] = []

31+ vadd (x :: xs) (y :: ys) = x + y :: vadd xs ys

32+

33+This function adds corresponding elements in a pair of vectors. The type

34+guarantees that the vectors will contain only elements of type ``Int``,

35+and that the input lengths and the output length all correspond. A

36+natural question to ask here, which is typically neglected by

37+introductory tutorials, is “How do I turn this into a program?” That is,

38+given some lists entered by a user, how do we get into a position to be

39+able to apply the ``vadd`` function? Before doing so, we will have to:

40+

41+- Read user input, either from the keyboard, a file, or some other input device.

42+

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+

45+- Write output

46+

47+The complete program will include side-effects for I/O and error

48+handling, before we can get to the pure core functionality. In this

49+tutorial, we will see how Idris supports side-effects.

50+Furthermore, we will see how we can use the dependent type system to

51+*reason* about stateful and side-effecting programs. We will return to

52+this specific example later.

53+

54+Hello world

55+===========

56+

57+To give an idea of how programs with effects look, here is the

58+ubiquitous “Hello world” program, written using the ``Effects``

59+library:

60+

61+.. code-block:: idris

62+

63+ module Main

64+

65+ import Effects

66+ import Effect.StdIO

67+

68+ hello : Eff () [STDIO]

69+ hello = putStrLn "Hello world!"

70+

71+ main : IO ()

72+ main = run hello

73+

74+As usual, the entry point is ``main``. All ``main`` has to do is invoke the

75+``hello`` function which supports the ``STDIO`` effect for console I/O, and

76+returns the unit value. All programs using the ``Effects`` library must

77+``import Effects``. The details of the ``Eff`` type will be presented in the

78+remainder of this tutorial.

79+

80+To compile and run this program, Idris needs to be told to include

81+the ``Effects`` package, using the ``-p effects`` flag (this flag is

82+required for all examples in this tutorial):

83+

84+.. code-block:: sh

85+

86+ idris hello.idr -o hello -p effects

87+ ./hello Hello world!

88+

89+Outline

90+=======

91+

92+The tutorial is structured as follows: first, in Section

93+:ref:`sect-state`, we will discuss state management, describing why it

94+is important and introducing the ``effects`` library to show how it

95+can be used to manage state. This section also gives an overview of

96+the syntax of effectful programs. Section :ref:`sect-simpleff` then

97+introduces a number of other effects a program may have: I/O;

98+Exceptions; Random Numbers; and Non-determinism, giving examples for

99+each, and an extended example combining several effects in one

100+complete program. Section :ref:`sect-depeff` introduces *dependent*

101+effects, showing how states and resources can be managed in

102+types. Section :ref:`sect-impleff` shows how new effects can be

103+implemented. Section :ref:`sect-hangman` gives an extended example

104+showing how to implement a “mystery word” guessing game, using effects

105+to describe the rules of the game and ensure they are implemented

106+accurately. References to further reading are given in Section

107+:ref:`sect-further`.

108+

109+.. [1]

110+ You do not, however, need to know what a monad is!

docs/effects/simpleeff.rstnew file+595

@@ -0,0 +1,595 @@

1+.. _sect-simpleff:

2+

3+**************

4+Simple Effects

5+**************

6+

7+So far we have seen how to write programs with locally mutable state

8+using the ``STATE`` effect. To recap, we have the definitions below

9+in a module ``Effect.State``

10+

11+.. code-block:: idris

12+

13+ module Effect.State

14+

15+ STATE : Type -> EFFECT

16+

17+ get : Eff x [STATE x]

18+ put : x -> Eff () [STATE x]

19+ putM : y -> Eff () [STATE x] [STATE y]

20+ update : (x -> x) -> Eff () [STATE x]

21+

22+ Handler State m where { ... }

23+

24+The last line, ``Handler State m where { ... }``, means that the ``STATE``

25+effect is usable in any computation context ``m``. That is, a program

26+which uses this effect and returns something of type ``a`` can be

27+evaluated to something of type ``m a`` using ``run``, for any

28+``m``. The lower case ``State`` is a data type describing the

29+operations which make up the ``STATE`` effect itself—we will go into

30+more detail about this in Section :ref:`sect-impleff`.

31+

32+In this section, we will introduce some other supported effects,

33+allowing console I/O, exceptions, random number generation and

34+non-deterministic programming. For each effect we introduce, we will

35+begin with a summary of the effect, its supported operations, and the

36+contexts in which it may be used, like that above for ``STATE``, and

37+go on to present some simple examples. At the end, we will see some

38+examples of programs which combine multiple effects.

39+

40+All of the effects in the library, including those described in this

41+section, are summarised in Appendix :ref:`sect-appendix`.

42+

43+Console I/O

44+===========

45+

46+Console I/O is supported with the ``STDIO``

47+effect, which allows reading and writing characters and strings to and

48+from standard input and standard output. Notice that there is a

49+constraint here on the computation context ``m``, because it only

50+makes sense to support console I/O operations in a context where we

51+can perform (or at the very least simulate) console I/O:

52+

53+.. code-block:: idris

54+

55+ module Effect.StdIO

56+

57+ STDIO : EFFECT

58+

59+ putChar : Char -> Eff () [STDIO]

60+ putStr : String -> Eff () [STDIO]

61+ putStrLn : String -> Eff () [STDIO]

62+

63+ getStr : Eff String [STDIO]

64+ getChar : Eff Char [STDIO]

65+

66+ Handler StdIO IO where { ... }

67+ Handler StdIO (IOExcept a) where { ... }

68+

69+Examples

70+--------

71+

72+A program which reads the user’s name, then says hello, can be written

73+as follows:

74+

75+.. code-block:: idris

76+

77+ hello : Eff () [STDIO]

78+ hello = do putStr "Name? "

79+ x <- getStr

80+ putStrLn ("Hello " ++ trim x ++ "!")

81+

82+We use ``trim`` here to remove the trailing newline from the

83+input. The resource associated with ``STDIO`` is simply the empty

84+tuple, which has a default value ``()``, so we can run this as

85+follows:

86+

87+.. code-block:: idris

88+

89+ main : IO ()

90+ main = run hello

91+

92+In ``hello`` we could also use ``!``-notation instead of ``x <-

93+getStr``, since we only use the string that is read once:

94+

95+.. code-block:: idris

96+

97+ hello : Eff () [STDIO]

98+ hello = do putStr "Name? "

99+ putStrLn ("Hello " ++ trim !getStr ++ "!")

100+

101+More interestingly, we can combine multiple effects in one

102+program. For example, we can loop, counting the number of people we’ve

103+said hello to:

104+

105+.. code-block:: idris

106+

107+ hello : Eff () [STATE Int, STDIO]

108+ hello = do putStr "Name? "

109+ putStrLn ("Hello " ++ trim !getStr ++ "!")

110+ update (+1)

111+ putStrLn ("I've said hello to: " ++ show !get ++ " people")

112+ hello

113+

114+The list of effects given in ``hello`` means that the function can

115+call ``get`` and ``put`` on an integer state, and any functions which

116+read and write from the console. To run this, ``main`` does not need

117+to be changed.

118+

119+Aside: Resource Types

120+---------------------

121+

122+To find out the resource type of an effect, if necessary (for example

123+if we want to initialise a resource explicitly with ``runInit`` rather

124+than using a default value with ``run``) we can run the

125+``resourceType`` function at the REPL:

126+

127+.. code-block:: idris

128+

129+ *ConsoleIO> resourceType STDIO

130+ () : Type

131+ *ConsoleIO> resourceType (STATE Int)

132+ Int : Type

133+

134+Exceptions

135+==========

136+

137+The ``EXCEPTION``

138+effect is declared in module ``Effect.Exception``. This allows programs

139+to exit immediately with an error, or errors to be handled more

140+generally:

141+

142+.. _eff-exception:

143+.. code-block:: idris

144+

145+ module Effect.Exception

146+

147+ EXCEPTION : Type -> EFFECT

148+

149+ raise : a -> Eff b [EXCEPTION a]

150+

151+ Handler (Exception a) Maybe where { ... }

152+ Handler (Exception a) List where { ... }

153+ Handler (Exception a) (Either a) where { ... }

154+ Handler (Exception a) (IOExcept a) where { ... }

155+ Show a => Handler (Exception a) IO where { ... }

156+

157+Example

158+-------

159+

160+Suppose we have a ``String`` which is expected to represent an integer

161+in the range ``0`` to ``n``. We can write a function ``parseNumber``

162+which returns an ``Int`` if parsing the string returns a number in the

163+appropriate range, or throws an exception otherwise. Exceptions are

164+parameterised by an error type:

165+

166+.. code-block:: idris

167+

168+ data Error = NotANumber | OutOfRange

169+

170+ parseNumber : Int -> String -> Eff Int [EXCEPTION Error]

171+ parseNumber num str

172+ = if all isDigit (unpack str)

173+ then let x = cast str in

174+ if (x >=0 && x <= num)

175+ then pure x

176+ else raise OutOfRange

177+ else raise NotANumber

178+

179+Programs which support the ``EXCEPTION`` effect can be run in any

180+context which has some way of throwing errors, for example, we can run

181+``parseNumber`` in the ``Either Error`` context. It returns a value of

182+the form ``Right x`` if successful:

183+

184+.. code-block:: idris

185+

186+ *Exception> the (Either Error Int) $ run (parseNumber 42 "20")

187+ Right 20 : Either Error Int

188+

189+Or ``Left e`` on failure, carrying the appropriate exception:

190+

191+.. code-block:: idris

192+

193+ *Exception> the (Either Error Int) $ run (parseNumber 42 "50")

194+ Left OutOfRange : Either Error Int

195+

196+ *Exception> the (Either Error Int) $ run (parseNumber 42 "twenty")

197+ Left NotANumber : Either Error Int

198+

199+In fact, we can do a little bit better with ``parseNumber``, and have

200+it return a *proof* that the integer is in the required range along

201+with the integer itself. One way to do this is define a type of

202+bounded integers, ``Bounded``:

203+

204+.. code-block:: idris

205+

206+ Bounded : Int -> Type

207+ Bounded x = (n : Int ** So (n >= 0 && n <= x))

208+

209+Recall that ``So`` is parameterised by a ``Bool``, and only ``So

210+True`` is inhabited. We can use ``choose`` to construct such a value

211+from the result of a dynamic check:

212+

213+.. code-block:: idris

214+

215+ data So : Bool -> Type where

216+ Oh : So True

217+

218+ choose : (b : Bool) -> Either (So b) (So (not b))

219+

220+We then write ``parseNumber`` using ``choose`` rather than an

221+``if/then/else`` construct, passing the proof it returns on success as

222+the boundedness proof:

223+

224+.. code-block:: idris

225+

226+ parseNumber : (x : Int) -> String -> Eff (Bounded x) [EXCEPTION Error]

227+ parseNumber x str

228+ = if all isDigit (unpack str)

229+ then let num = cast str in

230+ case choose (num >=0 && num <= x) of

231+ Left p => pure (num ** p)

232+ Right p => raise OutOfRange

233+ else raise NotANumber

234+

235+Random Numbers

236+==============

237+

238+Random number generation is also implemented by the library, in module

239+``Effect.Random``:

240+

241+.. code-block:: idris

242+

243+ module Effect.Random

244+

245+ RND : EFFECT

246+

247+ srand : Integer -> Eff () [RND]

248+ rndInt : Integer -> Integer -> Eff Integer [RND]

249+ rndFin : (k : Nat) -> Eff (Fin (S k)) [RND]

250+

251+ Handler Random m where { ... }

252+

253+Random number generation is considered side-effecting because its

254+implementation generally relies on some external source of randomness.

255+The default implementation here relies on an integer *seed*, which can

256+be set with ``srand``. A specific seed will lead to a predictable,

257+repeatable sequence of random numbers. There are two functions which

258+produce a random number:

259+

260+- ``rndInt``, which returns a random integer between the given lower

261+ and upper bounds.

262+

263+- ``rndFin``, which returns a random element of a finite set

264+ (essentially a number with an upper bound given in its type).

265+

266+Example

267+-------

268+

269+We can use the ``RND`` effect to implement a simple guessing game. The

270+``guess`` function, given a target number, will repeatedly ask the

271+user for a guess, and state whether the guess is too high, too low, or

272+correct:

273+

274+.. code-block:: idris

275+

276+ guess : Int -> Eff () [STDIO]

277+

278+For reference, the code for ``guess`` is given below:

279+

280+.. _eff-game:

281+.. code-block:: idris

282+

283+ guess : Int -> Eff () [STDIO]

284+ guess target

285+ = do putStr "Guess: "

286+ case run {m=Maybe} (parseNumber 100 (trim !getStr)) of

287+ Nothing => do putStrLn "Invalid input"

288+ guess target

289+ Just (v ** _) =>

290+ case compare v target of

291+ LT => do putStrLn "Too low"

292+ guess target

293+ EQ => putStrLn "You win!"

294+ GT => do putStrLn "Too high"

295+ guess target

296+

297+Note that we use ``parseNumber`` as defined previously to read user input, but

298+we don’t need to list the ``EXCEPTION`` effect because we use a nested ``run``

299+to invoke ``parseNumber``, independently of the calling effectful program.

300+

301+To invoke this, we pick a random number within the range 0–100,

302+having set up the random number generator with a seed, then run

303+``guess``:

304+

305+.. code-block:: idris

306+

307+ game : Eff () [RND, STDIO]

308+ game = do srand 123456789

309+ guess (fromInteger !(rndInt 0 100))

310+

311+ main : IO ()

312+ main = run game

313+

314+If no seed is given, it is set to the ``default`` value. For a less

315+predictable game, some better source of randomness would be required,

316+for example taking an initial seed from the system time. To see how to

317+do this, see the ``SYSTEM`` effect described in :ref:`sect-appendix`.

318+

319+

320+Non-determinism

321+===============

322+

323+The listing below gives the definition of the non-determinism

324+effect, which allows a program to choose a value non-deterministically

325+from a list of possibilities in such a way that the entire computation

326+succeeds:

327+

328+.. code-block:: idris

329+

330+ import Effects

331+ import Effect.Select

332+

333+ SELECT : EFFECT

334+

335+ select : List a -> Eff a [SELECT]

336+

337+ Handler Selection Maybe where { ... }

338+ Handler Selection List where { ... }

339+

340+Example

341+-------

342+

343+The ``SELECT`` effect can be used to solve constraint problems, such

344+as finding Pythagorean triples. The idea is to use ``select`` to give

345+a set of candidate values, then throw an exception for any combination

346+of values which does not satisfy the constraint:

347+

348+.. code-block:: idris

349+

350+ triple : Int -> Eff (Int, Int, Int) [SELECT, EXCEPTION String]

351+ triple max = do z <- select [1..max]

352+ y <- select [1..z]

353+ x <- select [1..y]

354+ if (x * x + y * y == z * z)

355+ then pure (x, y, z)

356+ else raise "No triple"

357+

358+This program chooses a value for ``z`` between ``1`` and ``max``, then

359+values for ``y`` and ``x``. In operation, after a ``select``, the

360+program executes the rest of the ``do``-block for every possible

361+assignment, effectively searching depth-first. If the list is empty

362+(or an exception is thrown) execution fails.

363+

364+There are handlers defined for ``Maybe`` and ``List`` contexts, i.e.

365+contexts which can capture failure. Depending on the context ``m``,

366+``triple`` will either return the first triple it finds (if in

367+``Maybe`` context) or all triples in the range (if in ``List``

368+context). We can try this as follows:

369+

370+.. code-block:: idris

371+

372+ main : IO ()

373+ main = do print $ the (Maybe _) $ run (triple 100)

374+ print $ the (List _) $ run (triple 100)

375+

376+``vadd`` revisited

377+==================

378+

379+We now return to the ``vadd`` program from the introduction. Recall the

380+definition:

381+

382+.. code-block:: idris

383+

384+ vadd : Vect n Int -> Vect n Int -> Vect n Int

385+ vadd [] [] = []

386+ vadd (x :: xs) (y :: ys) = x + y :: vadd xs ys

387+

388+Using , we can set up a program so that it reads input from a user,

389+checks that the input is valid (i.e both vectors contain integers, and

390+are the same length) and if so, pass it on to ``vadd``. First, we

391+write a wrapper for ``vadd`` which checks the lengths and throw an

392+exception if they are not equal. We can do this for input vectors of

393+length ``n`` and ``m`` by matching on the implicit arguments ``n`` and

394+``m`` and using ``decEq`` to produce a proof of their equality, if

395+they are equal:

396+

397+.. code-block:: idris

398+

399+ vadd_check : Vect n Int -> Vect m Int ->

400+ Eff (Vect m Int) [EXCEPTION String]

401+ vadd_check {n} {m} xs ys with (decEq n m)

402+ vadd_check {n} {m=n} xs ys | (Yes Refl) = pure (vadd xs ys)

403+ vadd_check {n} {m} xs ys | (No contra) = raise "Length mismatch"

404+

405+To read a vector from the console, we implement a function of the

406+following type:

407+

408+.. code-block:: idris

409+

410+ read_vec : Eff (p ** Vect p Int) [STDIO]

411+

412+This returns a dependent pair of a length, and a vector of that

413+length, because we cannot know in advance how many integers the user

414+is going to input. We can use ``-1`` to indicate the end of input:

415+

416+.. code-block:: idris

417+

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"

422+ read_vec

423+ Just v => if (v /= -1)

424+ then do (_ ** xs) <- read_vec

425+ pure (_ ** v :: xs)

426+ else pure (_ ** [])

427+ where

428+ parseNumber : String -> Eff Int [EXCEPTION String]

429+ parseNumber str

430+ = if all (\x => isDigit x || x == '-') (unpack str)

431+ then pure (cast str)

432+ else raise "Not a number"

433+

434+This uses a variation on ``parseNumber`` which does not require a

435+number to be within range.

436+

437+Finally, we write a program which reads two vectors and prints the

438+result of pairwise addition of them, throwing an exception if the

439+inputs are of differing lengths:

440+

441+.. code-block:: idris

442+

443+ do_vadd : Eff () [STDIO, EXCEPTION String]

444+ do_vadd = do putStrLn "Vector 1"

445+ (_ ** xs) <- read_vec

446+ putStrLn "Vector 2"

447+ (_ ** ys) <- read_vec

448+ putStrLn (show !(vadd_check xs ys))

449+

450+By having explicit lengths in the type, we can be sure that ``vadd``

451+is only being used where the lengths of inputs are guaranteed to be

452+equal. This does not stop us reading vectors from user input, but it

453+does require that the lengths are checked and any discrepancy is dealt

454+with gracefully.

455+

456+

457+Example: An Expression Calculator

458+=================================

459+

460+To show how these effects can fit together, let us consider an

461+evaluator for a simple expression language, with addition and integer

462+values.

463+

464+.. code-block:: idris

465+

466+ data Expr = Val Integer

467+ | Add Expr Expr

468+

469+An evaluator for this language always returns an ``Integer``, and

470+there are no situations in which it can fail!

471+

472+.. code-block:: idris

473+

474+ eval : Expr -> Integer

475+ eval (Val x) = x

476+ eval (Add l r) = eval l + eval r

477+

478+If we add variables, however, things get more interesting. The

479+evaluator will need to be able to access the values stored in

480+variables, and variables may be undefined.

481+

482+.. code-block:: idris

483+

484+ data Expr = Val Integer

485+ | Var String

486+ | Add Expr Expr

487+

488+To start, we will change the type of ``eval`` so that it is effectful,

489+and supports an exception effect for throwing errors, and a state

490+containing a mapping from variable names (as ``String``) to their

491+values:

492+

493+.. code-block:: idris

494+

495+ Env : Type

496+ Env = List (String, Integer)

497+

498+ eval : Expr -> Eff Integer [EXCEPTION String, STATE Env]

499+ eval (Val x) = pure x

500+ eval (Add l r) = pure $ !(eval l) + !(eval r)

501+

502+Note that we are using ``!``-notation to avoid having to bind

503+subexpressions in a ``do`` block. Next, we add a case for evaluating

504+``Var``:

505+

506+.. code-block:: idris

507+

508+ eval (Var x) = case lookup x !get of

509+ Nothing => raise $ "No such variable " ++ x

510+ Just val => pure val

511+

512+This retrieves the state (with ``get``, supported by the ``STATE Env``

513+effect) and raises an exception if the variable is not in the

514+environment (with ``raise``, supported by the ``EXCEPTION String``

515+effect).

516+

517+To run the evaluator on a particular expression in a particular

518+environment of names and their values, we can write a function which

519+sets the state then invokes ``eval``:

520+

521+.. code-block:: idris

522+

523+ runEval : List (String, Integer) -> Expr -> Maybe Integer

524+ runEval args expr = run (eval' expr)

525+ where eval' : Expr -> Eff Integer [EXCEPTION String, STATE Env]

526+ eval' e = do put args

527+ eval e

528+

529+We have picked ``Maybe`` as a computation context here; it needs to be

530+a context which is available for every effect supported by

531+``eval``. In particular, because we have exceptions, it needs to be a

532+context which supports exceptions. Alternatively, ``Either String`` or

533+``IO`` would be fine, for example.

534+

535+What if we want to extend the evaluator further, with random number

536+generation? To achieve this, we add a new constructor to ``Expr``,

537+which gives a random number up to a maximum value:

538+

539+.. code-block:: idris

540+

541+ data Expr = Val Integer

542+ | Var String

543+ | Add Expr Expr

544+ | Random Integer

545+

546+Then, we need to deal with the new case, making sure that we extend

547+the list of events to include ``RND``. It doesn't matter where ``RND``

548+appears in the list, as long as it is present:

549+

550+.. code-block:: idris

551+

552+ eval : Expr -> Eff Integer [EXCEPTION String, RND, STATE Env]

553+

554+ eval (Random upper) = rndInt 0 upper

555+

556+For test purposes, we might also want to print the random number which

557+has been generated:

558+

559+.. code-block:: idris

560+

561+ eval (Random upper) = do val <- rndInt 0 upper

562+ putStrLn (show val)

563+ pure val

564+

565+If we try this without extending the effects list, we would see an

566+error something like the following:

567+

568+::

569+

570+ Expr.idr:28:6:When elaborating right hand side of eval:

571+ Can't solve goal

572+ SubList [STDIO]

573+ [(EXCEPTION String), RND, (STATE (List (String, Integer)))]

574+

575+In other words, the ``STDIO`` effect is not available. We can correct

576+this simply by updating the type of ``eval`` to include ``STDIO``.

577+

578+.. code-block:: idris

579+

580+ eval : Expr -> Eff Integer [STDIO, EXCEPTION String, RND, STATE Env]

581+

582+.. note:: Using ``STDIO`` will restrict the number of contexts in

583+ which ``eval`` can be ``run`` to those which support

584+ ``STDIO``, such as ``IO``. Once effect lists get longer, it

585+ can be a good idea instead to encapsulate sets of effects in

586+ a type synonym. This is achieved as follows, simply by

587+ defining a function which computes a type, since types are

588+ first class in Idris:

589+

590+ .. code-block:: idris

591+

592+ EvalEff : Type -> Type

593+ EvalEff t = Eff t [STDIO, EXCEPTION String, RND, STATE Env]

594+

595+ eval : Expr -> EvalEff Integer

docs/effects/state.rstnew file+529

@@ -0,0 +1,529 @@

1+.. _sect-state:

2+

3+*****

4+State

5+*****

6+

7+Many programs, even pure programs, can benefit from locally mutable

8+state. For example, consider a program which tags binary tree nodes

9+with a counter, by an inorder traversal (i.e. counting depth first,

10+left to right). This would perform something like the following:

11+

12+|image|

13+

14+We can describe binary trees with the following data type ``BTree``

15+and ``testTree`` to represent the example input above:

16+

17+.. code-block:: idris

18+

19+ data BTree a = Leaf

20+ | Node (BTree a) a (BTree a)

21+

22+ testTree : BTree String

23+ testTree = Node (Node Leaf "Jim" Leaf)

24+ "Fred"

25+ (Node (Node Leaf "Alice" Leaf)

26+ "Sheila"

27+ (Node Leaf "Bob" Leaf))

28+

29+Then our function to implement tagging, beginning to tag with a

30+specific value ``i``, has the following type:

31+

32+.. code-block:: idris

33+

34+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)

35+

36+First attempt

37+=============

38+

39+Naïvely, we can implement ``treeTag`` by implementing a helper

40+function which propagates a counter, returning the result of the count

41+for each subtree:

42+

43+.. code-block:: idris

44+

45+ treeTagAux : (i : Int) -> BTree a -> (Int, BTree (Int, a))

46+ treeTagAux i Leaf = (i, Leaf)

47+ treeTagAux i (Node l x r)

48+ = let (i', l') = treeTagAux i l in

49+ let x' = (i', x) in

50+ let (i'', r') = treeTagAux (i' + 1) r in

51+ (i'', Node l' x' r')

52+

53+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)

54+ treeTag i x = snd (treeTagAux i x)

55+

56+This gives the expected result when run at the REPL prompt:

57+

58+.. code-block:: idris

59+

60+ *TreeTag> treeTag 1 testTree

61+ Node (Node Leaf (1, "Jim") Leaf)

62+ (2, "Fred")

63+ (Node (Node Leaf (3, "Alice") Leaf)

64+ (4, "Sheila")

65+ (Node Leaf (5, "Bob") Leaf)) : BTree (Int, String)

66+

67+This works as required, but there are several problems when we try to

68+scale this to larger programs. It is error prone, because we need to

69+ensure that state is propagated correctly to the recursive calls (i.e.

70+passing the appropriate ``i`` or ``i’``). It is hard to read, because

71+the functional details are obscured by the state propagation. Perhaps

72+most importantly, there is a common programming pattern here which

73+should be abstracted but instead has been implemented by hand. There

74+is local mutable state (the counter) which we have had to make

75+explicit.

76+

77+Introducing ``Effects``

78+=======================

79+

80+Idris provides a library, ``Effects`` [3]_, which captures this

81+pattern and many others involving effectful computation [1]_. An

82+effectful program ``f`` has a type of the following form:

83+

84+.. code-block:: idris

85+

86+ f : (x1 : a1) -> (x2 : a2) -> ... -> Eff t effs

87+

88+That is, the return type gives the effects that ``f`` supports

89+(``effs``, of type ``List EFFECT``) and the type the computation

90+returns ``t``. So, our ``treeTagAux`` helper could be written with the

91+following type:

92+

93+.. code-block:: idris

94+

95+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE Int]

96+

97+That is, ``treeTagAux`` has access to an integer state, because the

98+list of available effects includes ``STATE Int``. ``STATE`` is

99+declared as follows in the module ``Effect.State`` (that is, we must

100+``import Effect.State`` to be able to use it):

101+

102+.. code-block:: idris

103+

104+ STATE : Type -> EFFECT

105+

106+It is an effect parameterised by a type (by convention, we write

107+effects in all capitals). The ``treeTagAux`` function is an effectful

108+program which builds a new tree tagged with ``Ints``, and is

109+implemented as follows:

110+

111+.. code-block:: idris

112+

113+ treeTagAux Leaf = pure Leaf

114+ treeTagAux (Node l x r)

115+ = do l' <- treeTagAux l

116+ i <- get

117+ put (i + 1)

118+ r' <- treeTagAux r

119+ pure (Node l' (i, x) r')

120+

121+There are several remarks to be made about this implementation.

122+Essentially, it hides the state, which can be accessed using ``get``

123+and updated using ``put``, but it introduces several new features.

124+Specifically, it uses ``do``-notation, binding variables with ``<-``,

125+and a ``pure`` function. There is much to be said about these

126+features, but for our purposes, it suffices to know the following:

127+

128+- ``do`` blocks allow effectful operations to be sequenced.

129+

130+- ``x <- e`` binds the result of an effectful operation ``e`` to a

131+ variable ``x``. For example, in the above code, ``treeTagAux l`` is

132+ an effectful operation returning ``BTree (Int, a)``, so ``l’`` has

133+ type ``BTree (Int, a)``.

134+

135+- ``pure e`` turns a pure value ``e`` into the result of an effectful

136+ operation.

137+

138+The ``get`` and ``put`` functions read and write a state ``t``,

139+assuming that the ``STATE t`` effect is available. They have the

140+following types, polymorphic in the state ``t`` they manage:

141+

142+.. code-block:: idris

143+

144+ get : Eff t [STATE t]

145+ put : t -> Eff () [STATE t]

146+

147+A program in ``Eff`` can call any other function in ``Eff`` provided

148+that the calling function supports at least the effects required by

149+the called function. In this case, it is valid for ``treeTagAux`` to

150+call both ``get`` and ``put`` because all three functions support the

151+``STATE Int`` effect.

152+

153+Programs in ``Eff`` are run in some underlying *computation context*,

154+using the ``run`` or ``runPure`` function. Using ``runPure``, which

155+runs an effectful program in the identity context, we can write the

156+``treeTag`` function as follows, using ``put`` to initialise the

157+state:

158+

159+.. code-block:: idris

160+

161+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)

162+ treeTag i x = runPure (do put i

163+ treeTagAux x)

164+

165+We could also run the program in an impure context such as ``IO``,

166+without changing the definition of ``treeTagAux``, by using ``run``

167+instead of ``runPure``:

168+

169+.. code-block:: idris

170+

171+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE Int]

172+ ...

173+

174+ treeTag : (i : Int) -> BTree a -> IO (BTree (Int, a))

175+ treeTag i x = run (do put i

176+ treeTagAux x)

177+

178+Note that the definition of ``treeTagAux`` is exactly as before. For

179+reference, this complete program (including a ``main`` to run it) is

180+shown in Listing [introprog].

181+

182+.. code-block:: idris

183+

184+ module Main

185+

186+ import Effects

187+ import Effect.State

188+

189+ data BTree a = Leaf

190+ | Node (BTree a) a (BTree a)

191+

192+ Show a => Show (BTree a) where

193+ show Leaf = "[]"

194+ show (Node l x r) = "[" ++ show l ++ " "

195+ ++ show x ++ " "

196+ ++ show r ++ "]"

197+

198+ testTree : BTree String

199+ testTree = Node (Node Leaf "Jim" Leaf)

200+ "Fred"

201+ (Node (Node Leaf "Alice" Leaf)

202+ "Sheila"

203+ (Node Leaf "Bob" Leaf))

204+

205+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE Int]

206+ treeTagAux Leaf = pure Leaf

207+ treeTagAux (Node l x r) = do l' <- treeTagAux l

208+ i <- get

209+ put (i + 1)

210+ r' <- treeTagAux r

211+ pure (Node l' (i, x) r')

212+

213+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)

214+ treeTag i x = runPure (do put i; treeTagAux x)

215+

216+ main : IO ()

217+ main = print (treeTag 1 testTree)

218+

219+Effects and Resources

220+=====================

221+

222+Each effect is associated with a *resource*, which is initialised

223+before an effectful program can be run. For example, in the case of

224+``STATE Int`` the corresponding resource is the integer state itself.

225+The types of ``runPure`` and ``run`` show this (slightly simplified

226+here for illustrative purposes):

227+

228+.. code-block:: idris

229+

230+ runPure : {env : Env id xs} -> Eff a xs -> a

231+ run : Applicative m => {env : Env m xs} -> Eff a xs -> m a

232+

233+The ``env`` argument is implicit, and initialised automatically where

234+possible using default values given by implementations of the following

235+interface:

236+

237+.. code-block:: idris

238+

239+ interface Default a where

240+ default : a

241+

242+Implementations of ``Default`` are defined for all primitive types, and many

243+library types such as ``List``, ``Vect``, ``Maybe``, pairs, etc.

244+However, where no default value exists for a resource type (for

245+example, you may want a ``STATE`` type for which there is no

246+``Default`` implementation) the resource environment can be given explicitly

247+using one of the following functions:

248+

249+.. code-block:: idris

250+

251+ runPureInit : Env id xs -> Eff a xs -> a

252+ runInit : Applicative m => Env m xs -> Eff a xs -> m a

253+

254+To be well-typed, the environment must contain resources corresponding

255+exactly to the effects in ``xs``. For example, we could also have

256+implemented ``treeTag`` by initialising the state as follows:

257+

258+.. code-block:: idris

259+

260+ treeTag : (i : Int) -> BTree a -> BTree (Int, a)

261+ treeTag i x = runPureInit [i] (treeTagAux x)

262+

263+Labelled Effects

264+================

265+

266+What if we have more than one state, especially more than one state of

267+the same type? How would ``get`` and ``put`` know which state they

268+should be referring to? For example, how could we extend the tree

269+tagging example such that it additionally counts the number of leaves

270+in the tree? One possibility would be to change the state so that it

271+captured both of these values, e.g.:

272+

273+.. code-block:: idris

274+

275+ treeTagAux : BTree a -> Eff (BTree (Int, a)) [STATE (Int, Int)]

276+

277+Doing this, however, ties the two states together throughout (as well

278+as not indicating which integer is which). It would be nice to be able

279+to call effectful programs which guaranteed only to access one of the

280+states, for example. In a larger application, this becomes

281+particularly important.

282+

283+The library therefore allows effects in general to be *labelled* so

284+that they can be referred to explicitly by a particular name. This

285+allows multiple effects of the same type to be included. We can count

286+leaves and update the tag separately, by labelling them as follows:

287+

288+.. code-block:: idris

289+

290+ treeTagAux : BTree a -> Eff (BTree (Int, a))

291+ ['Tag ::: STATE Int,

292+ 'Leaves ::: STATE Int]

293+

294+The ``:::`` operator allows an arbitrary label to be given to an

295+effect. This label can be any type—it is simply used to identify an

296+effect uniquely. Here, we have used a symbol type. In general

297+``’name`` introduces a new symbol, the only purpose of which is to

298+disambiguate values [2]_.

299+

300+When an effect is labelled, its operations are also labelled using the

301+``:-`` operator. In this way, we can say explicitly which state we

302+mean when using ``get`` and ``put``. The tree tagging program which

303+also counts leaves can be written as follows:

304+

305+.. code-block:: idris

306+

307+ treeTagAux Leaf = do

308+ 'Leaves :- update (+1)

309+ pure Leaf

310+ treeTagAux (Node l x r) = do

311+ l' <- treeTagAux l

312+ i <- 'Tag :- get

313+ 'Tag :- put (i + 1)

314+ r' <- treeTagAux r

315+ pure (Node l' (i, x) r')

316+

317+The ``update`` function here is a combination of ``get`` and ``put``,

318+applying a function to the current state.

319+

320+.. code-block:: idris

321+

322+ update : (x -> x) -> Eff () [STATE x]

323+

324+Finally, our top level ``treeTag`` function now returns a pair of the

325+number of leaves, and the new tree. Resources for labelled effects are

326+initialised using the ``:=`` operator (reminiscent of assignment in an

327+imperative language):

328+

329+.. code-block:: idris

330+

331+ treeTag : (i : Int) -> BTree a -> (Int, BTree (Int, a))

332+ treeTag i x = runPureInit ['Tag := i, 'Leaves := 0]

333+ (do x' <- treeTagAux x

334+ leaves <- 'Leaves :- get

335+ pure (leaves, x'))

336+

337+To summarise, we have:

338+

339+- ``:::`` to convert an effect to a labelled effect.

340+

341+- ``:-`` to convert an effectful operation to a labelled effectful operation.

342+

343+- ``:=`` to initialise a resource for a labelled effect.

344+

345+Or, more formally with their types (slightly simplified to account

346+only for the situation where available effects are not updated):

347+

348+.. code-block:: idris

349+

350+ (:::) : lbl -> EFFECT -> EFFECT

351+ (:-) : (l : lbl) -> Eff a [x] -> Eff a [l ::: x]

352+ (:=) : (l : lbl) -> res -> LRes l res

353+

354+Here, ``LRes`` is simply the resource type associated with a labelled

355+effect. Note that labels are polymorphic in the label type ``lbl``.

356+Hence, a label can be anything—a string, an integer, a type, etc.

357+

358+``!``-notation

359+==============

360+

361+In many cases, using ``do``-notation can make programs unnecessarily

362+verbose, particularly in cases where the value bound is used once,

363+immediately. The following program returns the length of the

364+``String`` stored in the state, for example:

365+

366+.. code-block:: idris

367+

368+ stateLength : Eff Nat [STATE String]

369+ stateLength = do x <- get

370+ pure (length x)

371+

372+This seems unnecessarily verbose, and it would be nice to program in a

373+more direct style in these cases. provides ``!``-notation to help with

374+this. The above program can be written instead as:

375+

376+.. code-block:: idris

377+

378+ stateLength : Eff Nat [STATE String]

379+ stateLength = pure (length !get)

380+

381+The notation ``!expr`` means that the expression ``expr`` should be

382+evaluated and then implicitly bound. Conceptually, we can think of

383+``!`` as being a prefix function with the following type:

384+

385+.. code-block:: idris

386+

387+ (!) : Eff a xs -> a

388+

389+Note, however, that it is not really a function, merely syntax! In

390+practice, a subexpression ``!expr`` will lift ``expr`` as high as

391+possible within its current scope, bind it to a fresh name ``x``, and

392+replace ``!expr`` with ``x``. Expressions are lifted depth first, left

393+to right. In practice, ``!``-notation allows us to program in a more

394+direct style, while still giving a notational clue as to which

395+expressions are effectful.

396+

397+For example, the expression:

398+

399+.. code-block:: idris

400+

401+ let y = 42 in f !(g !(print y) !x)

402+

403+is lifted to:

404+

405+.. code-block:: idris

406+

407+ let y = 42 in do y' <- print y

408+ x' <- x

409+ g' <- g y' x'

410+ f g'

411+

412+The Type ``Eff``

413+================

414+

415+Underneath, ``Eff`` is an overloaded function which translates to an

416+underlying type ``EffM``:

417+

418+.. code-block:: idris

419+

420+ EffM : (m : Type -> Type) -> (t : Type)

421+ -> (List EFFECT)

422+ -> (t -> List EFFECT) -> Type

423+

424+This is more general than the types we have been writing so far. It is

425+parameterised over an underlying computation context ``m``, a

426+result type ``t`` as we have already seen, as well as a ``List EFFECT`` and a

427+function type ``t -> List EFFECT``.

428+

429+These additional parameters are the list of *input* effects, and a

430+list of *output* effects, computed from the result of an effectful

431+operation. That is: running an effectful program can change the set

432+of effects available! This is a particularly powerful idea, and we

433+will see its consequences in more detail later. Some examples of

434+operations which can change the set of available effects are:

435+

436+- Updating a state containing a dependent type (for example adding an element to a vector).

437+

438+- Opening a file for reading is an effect, but whether the file really

439+ *is* open afterwards depends on whether the file was successfully

440+ opened.

441+

442+- Closing a file means that reading from the file should no longer be

443+ possible.

444+

445+While powerful, this can make uses of the ``EffM`` type hard to read.

446+Therefore the library provides an overloaded function ``Eff``

447+There are the following three versions:

448+

449+.. code-block:: idris

450+

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+

457+So far, we have used only the first version, ``SimpleEff.Eff``, which

458+is defined as follows:

459+

460+.. code-block:: idris

461+

462+ Eff : (x : Type) -> (es : List EFFECT) -> Type

463+ Eff x es = {m : Type -> Type} -> EffM m x es (\v => es)

464+

465+i.e. the set of effects remains the same on output. This suffices for

466+the ``STATE`` example we have seen so far, and for many useful

467+side-effecting programs. We could also have written ``treeTagAux``

468+with the expanded type:

469+

470+.. code-block:: idris

471+

472+ treeTagAux : BTree a ->

473+ EffM m (BTree (Int, a)) [STATE Int] (\x => [STATE Int])

474+

475+Later, we will see programs which update effects:

476+

477+.. code-block:: idris

478+

479+ Eff a xs xs'

480+

481+which is expanded to

482+

483+.. code-block:: idris

484+

485+ EffM m a xs (\_ => xs')

486+

487+i.e. the set of effects is updated to ``xs’`` (think of a transition

488+in a state machine). There is, for example, a version of ``put`` which

489+updates the type of the state:

490+

491+.. code-block:: idris

492+

493+ putM : y -> Eff () [STATE x] [STATE y]

494+

495+Also, we have:

496+

497+.. code-block:: idris

498+

499+ Eff t xs (\res => xs')

500+

501+which is expanded to

502+

503+.. code-block:: idris

504+

505+ EffM m t xs (\res => xs')

506+

507+i.e. the set of effects is updated according to the result of the

508+operation ``res``, of type ``t``.

509+

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.

514+

515+.. [1] The earlier paper [3]_ describes the essential implementation

516+ details, although the library presented there is an earlier version

517+ which is less powerful than that presented in this tutorial.

518+

519+.. [2] In practice, ``’name`` simply introduces a new empty type

520+

521+.. [3] Edwin Brady. 2013. Programming and reasoning with algebraic

522+ effects and dependent types. SIGPLAN Not. 48, 9 (September

523+ 2013), 133-144. DOI=10.1145/2544174.2500581

524+ http://dl.acm.org/citation.cfm?doid=2544174.2500581

525+

526+

527+

528+.. |image| image:: ../image/effects-tree.png

529+ :width: 500px

docs/effects/summary.rstnew file+152

@@ -0,0 +1,152 @@

1+.. _sect-appendix:

2+

3+***************

4+Effects Summary

5+***************

6+

7+This appendix gives interfaces for the core effects provided by the

8+library.

9+

10+EXCEPTION

11+=========

12+

13+.. code-block:: idris

14+

15+ module Effect.Exception

16+

17+ import Effects

18+ import System

19+ import Control.IOExcept

20+

21+ EXCEPTION : Type -> EFFECT

22+

23+ raise : a -> Eff b [EXCEPTION a]

24+

25+ Handler (Exception a) Maybe where { ... }

26+ Handler (Exception a) List where { ... }

27+ Handler (Exception a) (Either a) where { ... }

28+ Handler (Exception a) (IOExcept a) where { ... }

29+ Show a => Handler (Exception a) IO where { ... }

30+

31+FILE\_IO

32+========

33+

34+.. code-block:: idris

35+

36+ module Effect.File

37+

38+ import Effects

39+ import Control.IOExcept

40+

41+ FILE_IO : Type -> EFFECT

42+

43+ data OpenFile : Mode -> Type

44+

45+ open : (fname : String)

46+ -> (m : Mode)

47+ -> Eff Bool [FILE_IO ()]

48+ (\res => [FILE_IO (case res of

49+ True => OpenFile m

50+ False => ())])

51+ close : Eff () [FILE_IO (OpenFile m)] [FILE_IO ()]

52+

53+ readLine : Eff String [FILE_IO (OpenFile Read)]

54+ writeLine : String -> Eff () [FILE_IO (OpenFile Write)]

55+ eof : Eff Bool [FILE_IO (OpenFile Read)]

56+

57+ Handler FileIO IO where { ... }

58+

59+RND

60+===

61+

62+.. code-block:: idris

63+

64+ module Effect.Random

65+

66+ import Effects

67+ import Data.Vect

68+ import Data.Fin

69+

70+ RND : EFFECT

71+

72+ srand : Integer -> Eff () [RND]

73+ rndInt : Integer -> Integer -> Eff Integer [RND]

74+ rndFin : (k : Nat) -> Eff (Fin (S k)) [RND]

75+

76+ Handler Random m where { ... }

77+

78+SELECT

79+======

80+

81+.. code-block:: idris

82+

83+ module Effect.Select

84+

85+ import Effects

86+

87+ SELECT : EFFECT

88+

89+ select : List a -> Eff a [SELECT]

90+

91+ Handler Selection Maybe where { ... }

92+ Handler Selection List where { ... }

93+

94+STATE

95+=====

96+

97+.. code-block:: idris

98+

99+ module Effect.State

100+

101+ import Effects

102+

103+ STATE : Type -> EFFECT

104+

105+ get : Eff x [STATE x]

106+ put : x -> Eff () [STATE x]

107+ putM : y -> Eff () [STATE x] [STATE y]

108+ update : (x -> x) -> Eff () [STATE x]

109+

110+ Handler State m where { ... }

111+

112+STDIO

113+=====

114+

115+.. code-block:: idris

116+

117+ module Effect.StdIO

118+

119+ import Effects

120+ import Control.IOExcept

121+

122+ STDIO : EFFECT

123+

124+ putChar : Char -> Eff () [STDIO]

125+ putStr : String -> Eff () [STDIO]

126+ putStrLn : String -> Eff () [STDIO]

127+

128+ getStr : Eff String [STDIO]

129+ getChar : Eff Char [STDIO]

130+

131+ Handler StdIO IO where { ... }

132+ Handler StdIO (IOExcept a) where { ... }

133+

134+SYSTEM

135+======

136+

137+.. code-block:: idris

138+

139+ module Effect.System

140+

141+ import Effects

142+ import System

143+ import Control.IOExcept

144+

145+ SYSTEM : EFFECT

146+

147+ getArgs : Eff (List String) [SYSTEM]

148+ time : Eff Int [SYSTEM]

149+ getEnv : String -> Eff (Maybe String) [SYSTEM]

150+

151+ Handler System IO where { ... }

152+ Handler System (IOExcept a) where { ... }

docs/elaboratorReflection/elabReflection.rstnew file+60

@@ -0,0 +1,60 @@

1+Extending Idris using Elaborator Reflection

2+===========================================

3+

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.

5+

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`_.

7+

8+Compilation of Idris proceeds through a number of stages.

9+

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.

13+

14+.. image:: ../image/idrisTopLevel.png

15+ :width: 484px

16+ :height: 147px

17+ :alt: diagram illustrating these stages of Idris compilation

18+

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.

20+

21+.. list-table::

22+

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

25+ :width: 206px

26+ :height: 112px

27+ :alt: diagram comparing elaboration with proof assistant

28+

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:

31+

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.

34+

35+For more information about holes and guesses see `Dependently Typed Functional Programs and their Proofs by McBride 1999`_.

36+

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.

38+

39+.. image:: ../image/elabOverview.png

40+ :width: 410px

41+ :height: 282px

42+ :alt: diagram illustrating overview of TT language being generated from tactics.

43+

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:

45+

46+.. list-table::

47+

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

50+ :width: 310px

51+ :height: 203px

52+ :alt: diagram illustrating basis of code in logic

53+

54+.. target-notes::

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

59+

60+

docs/elaboratorReflection/elaborator-reflection.rstnew file+209

@@ -0,0 +1,209 @@

1+.. _elaborator-reflection:

2+

3+**********************************

4+Elaborator Reflection Introduction

5+**********************************

6+

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>`_.

11+

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.

14+

15+The Elaborator State

16+====================

17+

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.

24+

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``.

29+

30+

31+Running Elaborator Scripts

32+==========================

33+

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``:

40+

41+.. code-block:: idris

42+

43+ idNat : Nat -> Nat

44+ idNat = %runElab (do intro `{{x}}

45+ fill (Var `{{x}})

46+ solve)

47+

48+

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``.

56+

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:

60+

61+.. code-block:: idris

62+

63+ mkId : Elab ()

64+ mkId = do intro `{{x}}

65+ fill (Var `{{x}})

66+ solve

67+

68+ idNat : Nat -> Nat

69+ idNat = %runElab mkId

70+

71+ idUnit : () -> ()

72+ idUnit = %runElab mkId

73+

74+ idString : String -> String

75+ idString = %runElab mkId

76+

77+

78+Interactively Building Elab Scripts

79+===================================

80+

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.

85+

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

91+that fills the hole.

92+

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``.

98+

99+General-purpose commands:

100+

101+- ``:eval <EXPR>``, or ``:e <EXPR>`` for short, evaluates the provided expression

102+ and prints the result.

103+

104+- ``:type <EXPR>``, or ``:t <EXPR>`` for short, prints the provided expression

105+ together with its type.

106+

107+- ``:search <TYPE>`` searches for definitions having the provided type.

108+

109+- ``:doc <NAME>`` searches for definitions with the provided name and prints their

110+ documentation.

111+

112+

113+Commands for viewing the proof state:

114+

115+- ``:state`` displays the current state of the term being constructed. It lists both

116+ other goals and the current goal.

117+

118+- ``:term`` displays the current proof term as well as its yet-to-be-filled holes.

119+

120+

121+Commands for manipulating the proof state:

122+

123+- ``:undo`` undoes the effects of the last tactic.

124+

125+- ``:abandon`` gives up on proving the current lemma and quits the elaboration shell.

126+

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.

130+

131+

132+Failure

133+=======

134+

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.

138+

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.

143+

144+Querying the Elaboration State

145+==============================

146+

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:

150+

151+.. code-block:: idris

152+

153+ triv : Elab ()

154+ triv = do compute

155+ g <- getGoal

156+ case (snd g) of

157+ `(() : Type) => do fill `(() : ())

158+ solve

159+ otherGoal => fail [ TermPart otherGoal

160+ , TextPart "is not trivial"

161+ ]

162+

163+

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.

170+

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.

174+

175+Changing the Global Context

176+===========================

177+

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.

182+

183+Using Idris's Features

184+======================

185+

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.

190+

191+

192+Recursive Elaboration

193+=====================

194+

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.

198+

199+Learn More

200+==========

201+

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.

203+

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.

206+

207+For alternative ways to extend the Idris language see the :ref:`reference-index` section.

208+

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+========================================

3+

4+.. list-table::

5+

6+ * - This example of elaborator reflection steps through this metaprogram that generates the identity function:

7+ - .. code-block:: idris

8+

9+ %language ElabReflection

10+

11+ idNat : Nat -> Nat

12+ idNat = %runElab (do intro `{{x}}

13+ fill (Var `{{x}})

14+ solve)

15+

16+.. list-table::

17+ :widths: 200 100

18+

19+ * - At the beginning of executing the elaboration script, the initial state consists of a single hole of type Nat -> Nat.

20+

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

23+ :width: 119px

24+ :height: 109px

25+

26+The following is a walkthough looking at the state after each tactic:

27+

28+.. list-table::

29+

30+ * - Start with the type signature like this:

31+ - .. code-block:: idris

32+

33+ %language ElabReflection

34+

35+ idNat : Nat -> Nat

36+ idNat = %runElab (do

37+

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

40+ :width: 310px

41+ :height: 115px

42+

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

45+ :width: 277px

46+ :height: 15px

47+

48+ * - The term is:

49+ - ?{hole_0} ≈ ? {hole_2} . {hole_2} . {hole_0}

50+

51+ * - It is possible to read the state from the script by calling getEnv, getGoal and getHoles.

52+

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.

54+

55+ .. code-block:: idris

56+

57+ getEnv=[]

58+

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)

63+ })

64+ })

65+

66+ getHoles=[{hole_2},{hole_0}]

67+

68+ * - getGuess

69+ - error no guess

70+

71+ * - Introduce a lambda binding around the current hole and focus on the body.

72+ - intro \`{{x}}

73+

74+ * - The state now looks like this:

75+ - .. image:: ../image/elabProofStateEx1_2.png

76+ :width: 312px

77+ :height: 84px

78+

79+ * - The hole types now looks like this:

80+ - .. image:: ../image/elabLogicEx1_2.png

81+ :width: 279px

82+ :height: 26px

83+

84+ * - The term now looks like this:

85+ - ?{hole_0} ≈ λ x . ? {hole_2} . {hole_2} . {hole_0}

86+

87+ * - Again we can check the state by calling getEnv, getGoal and getHoles: see `my code`_

88+

89+ - .. code-block:: idris

90+

91+ getEnv=[(x, {λ (Nat.["Nat", "Prelude"]:{

92+ type constructor tag=8 number=0}).

93+ Type:U=(20:./Prelude/Nat.idr)

94+ })]

95+

96+ getGoal=(hole_2, {name ref{type constructor tag=8 number=0}

97+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)

98+ })

99+

100+ getHoles=[{hole_2},{hole_0}]

101+

102+ * - getGuess

103+ - error no guess

104+

105+ * - Place a term into a hole, unifying its type

106+ - fill (Var \`{{x}})

107+

108+ * - The state still looks like this:

109+ - .. image:: ../image/elabProofStateEx1_3.png

110+ :width: 312px

111+ :height: 57px

112+

113+ * - The hole types now looks like this:

114+ - .. image:: ../image/elabLogicEx1_3.png

115+ :width: 290px

116+ :height: 26px

117+

118+ * - The term now looks like this:

119+ - ?{hole_0} ≈ λ x . ?{hole_2} ≈ x . {hole_2} . {hole_0}

120+

121+ * - Again we can check the state by calling getEnv, getGoal and getHoles: see `my code`_

122+

123+ - .. code-block:: idris

124+

125+ getEnv=[(x, {λ (Nat.["Nat", "Prelude"]:

126+ {type constructor tag=8 number=0}).

127+ Type:U=(20:./Prelude/Nat.idr)

128+ })]

129+

130+ getGoal=(hole_2, {name ref{type constructor tag=8 number=0}

131+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)

132+ })

133+

134+ getHoles=[{hole_2}, {hole_0}]

135+

136+ * - getGuess

137+ - .. code-block:: idris

138+

139+ {name ref bound x:

140+ {name ref{type constructor tag=8 number=0}

141+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)

142+ }

143+ }

144+

145+ * - Substitute a guess into a hole.

146+ - solve

147+

148+ * - The hole types now looks like this:

149+ - .. image:: ../image/elabLogicEx1_4.png

150+ :width: 131px

151+ :height: 14px

152+

153+ * - The term now looks like this:

154+ - ?{hole_0} ≈ λ x . x . {hole_0}

155+

156+ * - getEnv

157+

158+ getGoal

159+

160+ getHoles

161+

162+ - .. code-block:: idris

163+

164+ getEnv=[]

165+

166+ getGoal=(hole_0, __pi_arg:(Nat.["Nat", "Prelude"]:{

167+ type constructor tag=8 number=0}.

168+ Type:U=(20:./Prelude/Nat.idr)

169+ ->.{name ref

170+ {type constructor tag=8 number=0}

171+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)

172+ })

173+ })

174+

175+ getHoles=[{hole_0}]

176+

177+ * - getGuess

178+ - .. code-block:: idris

179+

180+ x:({λ (Nat.["Nat", "Prelude"]:{

181+ type constructor tag=8 number=0}).

182+ Type:U=(20:./Prelude/Nat.idr)

183+ }.{

184+ name ref bound

185+ x:{name ref {type constructor tag=8 number=0}

186+ Nat.["Nat","Prelude"]:Type:U=(20:./Prelude/Nat.idr)

187+ }

188+ })

189+ }

190+

191+.. target-notes::

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+==================================================

3+

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.

7+

8+Generating Datatypes

9+--------------------

10+

11+There are two main 'tactics' associated with generating datatypes:

12+

13+- declareDatatype

14+- defineDatatype

15+

16+Which declare and define the datatype as the names suggest.

17+

18+.. list-table::

19+

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

22+ :width: 332px

23+ :height: 246px

24+ :alt: diagram illustrating data structures associated with declareDatatype defineDatatype.

25+

26+.. list-table::

27+

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

30+

31+ λΠ> :printdef Two

32+ data Two : Type where

33+ F : Two

34+ T : Two

35+

36+This was generated by the following code:

37+

38+.. code-block:: idris

39+

40+ module TwoDef

41+ %language ElabReflection

42+

43+ addTwo : Elab ()

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}})

51+ ]

52+

53+ %runElab addTwo

54+

55+.. list-table::

56+

57+ * - The constructors T and F can be called as would be expected:

58+ - .. code-block:: idris

59+

60+ λΠ> F

61+ F : Two

62+ λΠ> T

63+ T : Two

64+

65+Generating Functions

66+--------------------

67+

68+There are two main 'tactics' associated with generating functions:

69+

70+- declareType

71+- defineFunction

72+

73+Which declare and define the function as the names suggest.

74+

75+.. list-table::

76+

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

79+ :width: 332px

80+ :height: 246px

81+ :alt: diagram illustrating data structures associated with function declare and define.

82+

83+Note: The left hand side (lhs) and right hand side (rhs) of FunClause typically is of type 'Raw'.

84+

85+.. list-table::

86+

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

90+ :width: 264px

91+ :height: 239px

92+ :alt: diagram illustrating data structures associated with functions.

93+

94+.. list-table::

95+

96+ * - Some function definitions can now be added to the above datatype. This is what they will look like:

97+ - .. code-block:: idris

98+

99+ λΠ> :printdef perm1

100+ perm1 : Two -> Two

101+ perm1 F = F

102+ perm1 T = T

103+ λΠ> :printdef perm2

104+ perm2 : Two -> Two

105+ perm1 F = T

106+ perm1 T = F

107+

108+This was generated with the following code:

109+

110+.. code-block:: idris

111+

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)

117+ ]

118+

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)

124+ ]

125+

126+.. list-table::

127+

128+ * - This is what happens when we call the functions:

129+ - .. code-block:: idris

130+

131+ λΠ> perm1 F

132+ F : Two

133+ λΠ> perm1 T

134+ T : Two

135+ λΠ> perm2 F

136+ T : Two

137+ λΠ> perm2 T

138+ F : Two

139+

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.

141+

142+A Different Example which has Type Parameters

143+---------------------------------------------

144+

145+.. list-table::

146+

147+ * - Here is an example of a datatype with type parameters:

148+ - .. code-block:: idris

149+

150+ data N : Nat -> Type where

151+ MkN : N x

152+ MkN' : (x : Nat) -> N (S x)

153+

154+This was produced by the following code:

155+

156+.. code-block:: idris

157+

158+ module DataDef

159+ %language ElabReflection

160+

161+ addData : Elab ()

162+ addData = do

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}})))

170+ ]

171+

172+ %runElab addData

173+

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:

175+

176+.. code-block:: idris

177+

178+ λΠ> :t N

179+ N : Nat -> Type

180+ λΠ> N 2

181+ N 2 : Type

182+ λΠ> N 0

183+ N 0 : Type

184+ λΠ> :t MkN

185+ MkN : N x

186+

187+Table of 'tactics' for Generating Data and Functions

188+----------------------------------------------------

189+

190+These are the functions that we can use to create data and functions in the Elab monad:

191+

192+.. list-table::

193+ :widths: 10 30

194+ :stub-columns: 1

195+

196+ * - declareType

197+ - Add a type declaration to the global context.

198+

199+ Signature:

200+

201+ declareType : TyDecl -> Elab ()

202+ * - defineFunction

203+ - Define a function in the global context. The function must have already been declared, either in ordinary Idris code or using `declareType`.

204+

205+ Signature:

206+

207+ defineFunction : FunDefn Raw -> Elab ()

208+

209+ * - declareDatatype

210+ - Declare a datatype in the global context. This step only establishes the type constructor; use `defineDatatype` to give it constructors.

211+

212+ Signature:

213+

214+ declareDatatype : TyDecl -> Elab ()

215+

216+ * - defineDatatype

217+ - Signature:

218+

219+ defineDatatype : DataDefn -> Elab ()

220+

221+ * - addImplementation

222+ - Register a new implementation for interface resolution.

223+

224+ Arguments:

225+

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

228+

229+ Signature:

230+

231+ addImplementation : (ifaceName, implName : TTName) -> Elab ()

232+

233+ * - isTCName

234+ - Determine whether a name denotes an interface.

235+

236+ Arguments:

237+

238+ - name - a name that might denote an interface.

239+

240+ Signature:

241+

242+ isTCName : (name : TTName) -> Elab Bool

243+

244+Table of Datatypes Associated with Generating Data and Functions

245+----------------------------------------------------------------

246+

247+The above functions use the following data/records:

248+

249+.. list-table::

250+ :widths: 10 30

251+ :stub-columns: 1

252+

253+ * - Plicity

254+ - How an argument is provided in high-level Idris

255+

256+ .. code-block:: idris

257+

258+ data Plicity=

259+ ||| The argument is directly provided at the application site

260+ Explicit |

261+ ||| The argument is found by Idris at the application site

262+ Implicit |

263+ ||| The argument is solved using interface resolution

264+ Constraint

265+

266+ * - FunArg

267+ - Function arguments

268+

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.

271+

272+ .. code-block:: idris

273+

274+ record FunArg where

275+ constructor MkFunArg

276+ name : TTName

277+ type : Raw

278+ plicity : Plicity

279+ erasure : Erasure

280+

281+ * - TyConArg

282+ - Type constructor arguments

283+

284+ Each argument is identified as being either a parameter that is

285+

286+ consistent in all constructors, or an index that varies based on

287+

288+ which constructor is selected.

289+

290+ .. code-block:: idris

291+

292+ data TyConArg =

293+ ||| Parameters are uniform across the constructors

294+ TyConParameter FunArg |

295+ ||| Indices are not uniform

296+ TyConIndex FunArg

297+

298+ * - TyDecl

299+ - A type declaration for a function or datatype

300+

301+ .. code-block:: idris

302+

303+ record TyDecl where

304+ constructor Declare

305+ ||| The fully-qualified name of the function or datatype being declared.

306+ name : TTName

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.

310+ returnType : Raw

311+

312+ * - FunClause

313+ - A single pattern-matching clause

314+

315+ .. code-block:: idris

316+

317+ data FunClause : Type -> Type where

318+ MkFunClause : (lhs, rhs : a) -> FunClause a

319+ MkImpossibleClause : (lhs : a) -> FunClause a

320+

321+ * - FunDefn

322+ - A reflected function definition.

323+

324+ .. code-block:: idris

325+

326+ record FunDefn a where

327+ constructor DefineFun

328+ name : TTName

329+ clauses : List (FunClause a)

330+

331+ * - ConstructorDefn

332+ - A constructor to be associated with a new datatype.

333+

334+ .. code-block:: idris

335+

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.

340+ name : TTName

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.

345+ returnType : Raw

346+

347+ * - DataDefn

348+ - A definition of a datatype to be added during an elaboration script.

349+

350+ .. code-block:: idris

351+

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

356+ ||| datatype.

357+ name : TTName

358+ ||| A list of constructors for the datatype.

359+ constructors : List ConstructorDefn

360+

361+ * - CtorArg

362+ - CtorParameter

363+

364+ .. code-block:: idris

365+

366+ data CtorArg = CtorParameter FunArg | CtorField FunArg

367+

368+ * - Datatype

369+ - A reflected datatype definition

370+

371+ .. code-block:: idris

372+

373+ record Datatype where

374+ constructor MkDatatype

375+ ||| The name of the type constructor

376+ name : TTName

377+ ||| The arguments to the type constructor

378+ tyConArgs : List TyConArg

379+ ||| The result of the type constructor

380+ tyConRes : Raw

381+ ||| The constructors for the family

382+ constructors : List (TTName, List CtorArg, Raw)</td>

383+

384+.. target-notes::

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+=============================

3+

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'.

5+

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.

8+

9+The theory around this was developed in `Dependently Typed Functional Programs and their Proofs by McBride 1999`_.

10+

11+Notation for Holes and Guesses

12+------------------------------

13+

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.

15+

16+* A focused hole is notated like this ?x:t . t

17+* A guess is notated like this ?x ≈ t:t . t

18+

19+The following example shows how this is used:

20+

21+Simple Example

22+--------------

23+

24+Start with a code file that just contains:

25+

26+.. code-block:: idris

27+

28+ %language ElabReflection

29+

30+ testFn : Nat

31+ testFn = %runElab (do debug {a = ()})

32+

33+when this is loaded the following is displayed:

34+

35+.. code-block:: idris

36+

37+ Holes:

38+ ----------------------------------

39+ {hole_2} : Prelude.Nat.Nat

40+

41+ ----------------------------------

42+ {hole_0} : Prelude.Nat.Nat

43+

44+ Term:

45+ ?{hole_0} ≈ ? {hole_2} . {hole_2} . {hole_0}

46+

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.

48+

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.

51+

52+So starting with the "Term" part we have.

53+

54+.. code-block:: idris

55+

56+ ?{hole_0} ≈ ? {hole_2} . {hole_2} . {hole_0}

57+

58+.. sidebar:: attack tactic

59+

60+ This kind of thing tends to arise from "attack", which helps keep binding forms in order.

61+

62+The meaning of this is not immediately apparent so it helps to add some parentheses to make the structure clearer:

63+

64+.. code-block:: idris

65+

66+ (?{hole_0} ≈ (? {hole_2} . {hole_2}) . {hole_0})

67+

68+First lets look at the inner part:

69+

70+.. code-block:: idris

71+

72+ ? {hole_2} . {hole_2}

73+

74+We can substitute in the type from the "Holes" part:

75+

76+.. code-block:: idris

77+

78+ ? {hole_2}:Nat . {hole_2}:Nat

79+

80+So we are looking for a hole of type Nat and all we know is it has type Nat.

81+

82+Going back to the full term, the above is wrapped in a guess, so it means: 'a guess that is itself a hole'.

83+

84+Since the elaborator does not have any further information it has to be given a value:

85+

86+.. code-block:: idris

87+

88+ %language ElabReflection

89+

90+ testFn : Nat

91+ testFn = %runElab (do fill `(Z)

92+ debug {a = ()}

93+ solve)

94+

95+Now we have a guess for hole_2 which is itself a guess for hole_0:

96+

97+.. code-block:: idris

98+

99+ ?{hole_0} ≈ ?{hole_2} ≈ Prelude.Nat.Z . {hole_2} . {hole_0}

100+

101+The guesses can be accepted by calling the 'solve' tactic.

102+

103+Example Showing Patterns

104+------------------------

105+

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:

107+

108+.. code-block:: idris

109+

110+ %language ElabReflection

111+

112+ testFn : Nat -> Nat

113+ testFn n = %runElab (do debug {a = ()})

114+

115+when loaded gives:

116+

117+.. code-block:: idris

118+

119+ Holes:

120+ n : Prelude.Nat.Nat

121+ ----------------------------------

122+ {hole_3} : Prelude.Nat.Nat

123+

124+ n : Prelude.Nat.Nat

125+ ----------------------------------

126+ {hole_1} : Prelude.Nat.Nat

127+

128+ ----------------------------------

129+ {hole_0} : patTy n : Prelude.Nat.Nat . Prelude.Nat.Nat

130+

131+ Term:

132+ ?{hole_0} ≈ pat n : Prelude.Nat.Nat .

133+ ?{hole_1} ≈ ? {hole_3} . {hole_3} . {hole_1} .

134+ {hole_0}

135+

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!

137+

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.

139+

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).

141+

142+More Complicated Example

143+------------------------

144+

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:

146+

147+.. code-block:: idris

148+

149+ %language ElabReflection

150+

151+ testFn : (n : Nat) -> (n = plus n Z) -> (S n = S (plus n Z))

152+ testFn k ih = %runElab (do debug {a = ()})

153+

154+when loaded gives:

155+

156+.. code-block:: idris

157+

158+ Holes:

159+ k : Prelude.Nat.Nat

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))

165+

166+ k : Prelude.Nat.Nat

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))

172+

173+ k : Prelude.Nat.Nat

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))

179+

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))

186+

187+ Term:

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} .

192+ {hole_1} .

193+ {hole_0}

194+

195+.. target-notes::

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 @@

1+.. _elaborator-index:

2+

3+#####################

4+Elaborator Reflection

5+#####################

6+

7+A tutorial on theorem proving in Idris.

8+

9+.. note::

10+

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.

15+

16+ More information concerning the CC0 can be found online at: http://creativecommons.org/publicdomain/zero/1.0/

17+

18+.. toctree::

19+ :maxdepth: 1

20+

21+ elaborator-reflection

22+ elabReflection

23+ tactics

24+ holes

25+ example1

26+ primitive

27+ generatingData

docs/elaboratorReflection/primitive.rstnew file+518

@@ -0,0 +1,518 @@

1+Primitive Operators

2+===================

3+

4+.. list-table::

5+ :widths: 10 30

6+ :stub-columns: 1

7+

8+ * - gensym

9+ - Generate a unique name based on some hint.

10+

11+ Useful when establishing a new binder.

12+

13+ **NB**: the generated name is unique **for this run of the elaborator**.

14+

15+ Do not assume that they are globally unique.

16+

17+ Signature:

18+

19+ gensym : (hint : String) -> Elab TTName

20+

21+ * - solve

22+ - Substitute a guess into a hole.

23+

24+

25+ .. image:: ../image/solve.png

26+ :width: 141px

27+ :height: 74px

28+ :alt: diagram illustrating solve tactic

29+

30+

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.

32+

33+ Signature:

34+

35+ solve : Elab ()

36+

37+ Example:

38+

39+ .. code-block:: idris

40+

41+ %language ElabReflection

42+

43+ testFn : Nat

44+ testFn = %runElab (do fill `(Z)

45+ solve)

46+

47+ * - fill

48+ - Place a term into a hole, unifying its type. Fails if the focus is not a hole.

49+

50+

51+ .. image:: ../image/fill.png

52+ :width: 140px

53+ :height: 74px

54+ :alt: diagram illustrating fill tactic

55+

56+

57+ Signature:

58+

59+ fill : (e : Raw) -> Elab ()

60+

61+ Place a term e with type tc into the focused hole:

62+

63+ ?h : th.e'

64+

65+ and convert it to a guess:

66+

67+ ?h ≈ e:t.e'

68+

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.

70+

71+ This unification can result in the solution of further holes or the establishment of additional unsolved unification constraints.

72+

73+ Example:

74+

75+ .. code-block:: idris

76+

77+ %language ElabReflection

78+

79+ testFn : Nat

80+ testFn = %runElab (do fill `(Z)

81+ solve)

82+

83+ * - apply

84+ - Attempt to apply an operator to fill the current hole, potentially solving arguments by unification.

85+

86+ A hole is established for each argument.

87+

88+ The return value is the list of holes established for the arguments to the function.

89+

90+ Note that not all of the returned hole names still exist, as they may have been solved.

91+

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.

94+

95+ Signature:

96+

97+ apply : (op : Raw) -> (argSpec : List Bool) -> Elab (List TTName)

98+

99+ Example: elaborating an application of a function f that takes one implicit and two explicit arguments might invoke:

100+

101+ apply \`(f) [False, True, True]

102+

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.

104+

105+ .. code-block:: idris

106+

107+ do [x,y] <- apply `(plus) [False, False]

108+ solve

109+ focus x; fill `(Z); solve

110+ focus y; fill `(S Z); solve

111+

112+ The names of the established holes are returned.

113+

114+ Note: This was added to the original tactic language to allow elaborator reflection.

115+

116+ * - matchApply

117+ - Attempt to apply an operator to fill the current hole, potentially solving arguments by matching.

118+

119+ The return value is the list of holes established for the arguments to the function.

120+

121+ Note that not all of the returned hole names still exist, as they may have been solved.

122+

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.

125+

126+ Signature:

127+

128+ matchApply : (op : Raw) -> (argSpec : List Bool) -> Elab (List TTName)

129+

130+ * - focus

131+ - Move the focus to the specified hole, bringing it to the front of the hole queue. Fails if the hole does not exist.

132+

133+ @ hole the hole to focus on

134+

135+ Signature:

136+

137+ focus : (hole : TTName) -> Elab ()

138+

139+ * - unfocus

140+ - Send the currently-focused hole to the end of the hole queue and focus on the next hole.

141+

142+ Signature:

143+

144+ unfocus : TTName -> Elab ()

145+

146+ * - attack

147+ - Convert a hole to make it suitable for bindings.

148+

149+

150+ .. image:: ../image/attack.png

151+ :width: 152px

152+ :height: 70px

153+ :alt: diagram illustrating attack tactic

154+

155+

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.

157+

158+ Signature:

159+

160+ attack : Elab ()

161+

162+ * - claim

163+ - Establish a new hole binding named n with type t, surrounding the current focus.

164+

165+ Introduce a new hole with a specified name and type.

166+

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.

168+

169+ Signature:

170+

171+ claim : TTName -> Raw -> Elab ()

172+

173+ * - patvar

174+ - Convert a hole into a pattern variable.

175+

176+ Signature:

177+

178+ patvar : TTName -> Elab ()

179+

180+ * - compute

181+ - Normalise the goal.

182+

183+ Often this is not necessary because normanisation is applied during other tactics.

184+

185+ Signature:

186+

187+ compute : Elab ()

188+

189+ * - normalise

190+ - Normalise a term in some lexical environment

191+

192+ - @ env the environment in which to compute (get one of these from `getEnv`)

193+ - @ term the term to normalise

194+

195+ Signature:

196+

197+ normalise : (env : List (TTName, Binder TT)) -> (term : TT) -> Elab TT

198+

199+ * - whnf

200+ - Reduce a closed term to weak-head normal form

201+

202+ @ term the term to reduce

203+

204+ Signature:

205+

206+ whnf : (term : TT) -> Elab TT

207+

208+ * - convertsInEnv

209+ - Check that two terms are convertible in the current context and in some environment.

210+

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

214+

215+ Signature:

216+

217+ convertsInEnv : (env : List (TTName, Binder TT)) -> (term1, term2 : TT) -> Elab ()

218+

219+ * - converts

220+ - Check that two terms are convertable in the current context and environment

221+

222+ - @ term1 the first term to convert

223+ - @ term2 the second term to convertconverts : (term1, term2 : TT) -> Elab ()

224+

225+ converts term1 term2 = convertsInEnv !getEnv term1 term2

226+

227+ * - getSourceLocation

228+ - Find the source context for the elaboration script

229+

230+ Signature:

231+

232+ getSourceLocation : Elab SourceLocation

233+

234+ * - sourceLocation

235+ - Attempt to solve the current goal with the source code

236+

237+ locationsourceLocation : Elab ()

238+

239+ .. code-block:: idris

240+

241+ sourceLocation = do loc <- getSourceLocation

242+ fill (quote loc)

243+ solve

244+

245+ * - currentNamespace

246+ - Get the current namespace at the point of tactic execution. This allows scripts to define top-level names conveniently.

247+

248+ The namespace is represented as a reverse-order list of strings, just as in the representation of names.

249+

250+ Signature:

251+

252+ currentNamespace : Elab (List String)

253+

254+ * - rewriteWith

255+ - Attempt to rewrite the goal using an equality.

256+

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.

258+

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).

260+

261+ Signature:

262+

263+ rewriteWith : Raw -> Elab ()

264+

265+ * - resolveTC

266+ - Attempt to solve the current goal with an interface dictionary

267+

268+ @ fn the name of the definition being elaborated (to prevent Idris from looping)

269+

270+ Signature:

271+

272+ resolveTC : (fn : TTName) -> Elab ()

273+

274+ * - search

275+ - Use Idris's internal proof search.

276+

277+ Signature:

278+

279+ search : Elab ()

280+

281+ * - search'

282+ - Use Idris's internal proof search, with more control.

283+

284+ - @ depth the search depth

285+ - @ hints additional names to try

286+

287+ Signature:

288+

289+ search' : (depth : Int) -> (hints : List TTName) -> Elab ()

290+

291+ * - operatorFixity

292+ - Look up the declared fixity for an operator.

293+

294+ The lookup fails if the operator does not yet have a fixity or if the string is not a valid operator.

295+

296+ @ operator the operator string to look up

297+

298+ Signature:

299+

300+ operatorFixity : (operator : String) -> Elab Fixity

301+

302+ * - debug

303+ - Halt elaboration, dumping the internal state for inspection.

304+

305+ This is intended for elaboration script developers, not for end-users. Use `fail` for final scripts.

306+

307+ Signature:

308+

309+ debug : Elab a

310+

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).

312+

313+ .. code-block:: idris

314+

315+ %language ElabReflection

316+

317+ idNat : Nat -> Nat

318+ idNat = %runElab (do intro `{{x}}

319+ debug {a = ()}

320+ fill (Var `{{x}})

321+ solve)

322+

323+ * - debugMessage

324+ - Halt elaboration, dumping the internal state and displaying a message.

325+

326+ This is intended for elaboration script developers, not for end-users. Use `fail` for final scripts.

327+

328+ @ msg the message to display

329+

330+ Signature:

331+

332+ debugMessage : (msg : List ErrorReportPart) -> Elab a

333+

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).

335+

336+ .. code-block:: idris

337+

338+ %language ElabReflection

339+ idNat : Nat -> Nat

340+ idNat = %runElab (do intro `{{x}}

341+ debugMessage [TextPart "error message"] {a = ()}

342+ fill (Var `{{x}})

343+ solve)

344+

345+ * - metavar

346+ - Create a new top-level metavariable to solve the current hole.

347+

348+ @ name the name for the top-level variable

349+

350+ Signature:

351+

352+ metavar : (name : TTName) -> Elab ()

353+

354+ * - runElab

355+ - Recursively invoke the reflected elaborator with some goal.

356+

357+ The result is the final term and its type.

358+

359+ Signature:

360+

361+ runElab : Raw -> Elab () -> Elab (TT, TT)

362+

363+

364+Read and Write State

365+--------------------

366+

367+.. list-table::

368+ :widths: 10 30

369+ :stub-columns: 1

370+

371+ * - getEnv

372+ - Look up the lexical binding at the focused hole. Fails if no holes are present.

373+

374+ Signature:

375+

376+ getEnv : Elab (List (TTName, Binder TT))

377+

378+ * - getGoal

379+ - Get the name and type of the focused hole. Fails if not holes are present.

380+

381+ Signature:

382+

383+ getGoal : Elab (TTName, TT)

384+

385+ * - getHoles

386+ - Get the hole queue, in order.

387+

388+ Signature:

389+

390+ getHoles : Elab (List TTName)

391+

392+ * - getGuess

393+ - If the current hole contains a guess, return it. Otherwise, fail.

394+

395+ Signature:

396+

397+ getGuess : Elab TT

398+

399+ * - lookupTy

400+ - Look up the types of every overloading of a name.

401+

402+ Signature:

403+

404+ lookupTy : TTName -> Elab (List (TTName, NameType, TT))

405+

406+ * - lookupTyExact

407+ - Get the type of a fully-qualified name. Fail if it doesn't resolve uniquely.

408+

409+ Signature:

410+

411+ lookupTyExact : TTName -> Elab (TTName, NameType, TT)

412+

413+ * - lookupDatatype

414+ - Find the reflected representation of all datatypes whose names are overloadings of some name.

415+

416+ Signature:

417+

418+ lookupDatatype : TTName -> Elab (List Datatype)

419+

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.

422+

423+ Signature:

424+

425+ lookupDatatypeExact : TTName -> Elab Datatype

426+

427+ * - lookupFunDefn

428+ - Find the reflected function definition of all functions whose names are overloadings of some name.

429+

430+ Signature:

431+

432+ lookupFunDefn : TTName -> Elab (List (FunDefn TT))

433+

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.

436+

437+ Signature:

438+

439+ lookupFunDefnExact : TTName -> Elab (FunDefn TT)

440+

441+ * - lookupArgs

442+ - Get the argument specification for each overloading of a name.

443+

444+ Signature:

445+

446+ lookupArgs : TTName -> Elab (List (TTName, List FunArg, Raw))

447+

448+ * - lookupArgsExact

449+ - Get the argument specification for a name. Fail if the name does not uniquely resolve.

450+

451+ Signature:

452+

453+ lookupArgsExact : TTName -> Elab (TTName, List FunArg, Raw)

454+

455+ * - check

456+ - Attempt to type-check a term, getting back itself and its type.

457+

458+ - @ env the environment within which to check the type

459+ - @ tm the term to check

460+

461+ Signature:

462+

463+ check : (env : List (TTName, Binder TT)) -> (tm : Raw) -> Elab (TT, TT)

464+

465+Error Handling

466+--------------

467+

468+.. list-table::

469+ :widths: 10 30

470+ :stub-columns: 1

471+

472+ * - tryCatch

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.

475+

476+ Signature:

477+

478+ tryCatch : Elab a -> (Err -> Elab a) -> Elab a

479+

480+ .. code-block:: idris

481+

482+ %language ElabReflection

483+

484+ f : Err -> Elab ()

485+ f (Msg _) = fill `("message error")

486+ f (CantUnify _ _ _ _ _ _) = fill `("unification error")

487+ f _ = fill `("other")

488+

489+ s2 : String

490+ s2 = %runElab (do tryCatch (fill `(True)) f ; solve)

491+

492+ * - fail

493+ - Halt elaboration with an error

494+

495+ Signature:

496+

497+ fail : List ErrorReportPart -> Elab a

498+

499+ Note: we may need to make sure the return type 'a' is sufficiently constrained. If required add an explicit type {a = ()}.

500+

501+ Below is some code which includes 'fail'. This will always fail but we could replace 'True' with some more useful condition.

502+

503+ .. code-block:: idris

504+

505+ %language ElabReflection

506+

507+ id1 : Elab ()

508+ id1 = do

509+ intro `{{x}}

510+ fill (Var `{{x}})

511+ if True

512+ then

513+ fail [TextPart "put error message here"]

514+ else

515+ solve

516+

517+ idNat : Nat -> Nat

518+ idNat = %runElab id1

docs/elaboratorReflection/tactics.rstnew file+430

@@ -0,0 +1,430 @@

1+Elaborator Reflection - Tactics

2+===============================

3+

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.

7+

8+

9+Proof State

10+-----------

11+

12+The terminology 'Proof State' is used by analogy to proof assistants but, as used here, it's really more of a metaprogramming state.

13+

14+Tactics operate on the proof state. The proof state contains various pieces of information, at this stage, the important ones for us are:

15+

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.

20+

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.

22+

23+.. image:: ../image/elabProofState.png

24+ :width: 283px

25+ :height: 232px

26+

27+Names TTName

28+------------

29+

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:

32+

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++---------------------------+-----------------------------------------------+

43+

44+

45+A user defined name can be constructed like this:

46+

47+.. code-block:: idris

48+

49+ Idris> UN "x"

50+ UN "x" : TTName

51+

52+.. code-block:: idris

53+

54+ Idris> NS (UN "x") ["b","a"]

55+ NS (UN "x") ["b", "a"] : TTName

56+

57+.. list-table:: machine-chosen names

58+

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:

61+

62+ .. code-block:: idris

63+

64+ implementation Show TTName where

65+ show (UN s) = "`{{"++s++"}}"

66+ show (NS t a) = "{"++(show t)++

67+ "."++(show a)++"}"

68+ show (MN i s) = "{"++s++"_"++(show i)++"}"

69+ show (SN sn) = "TTName special name"

70+

71+ showGensym : String

72+ showGensym = %runElab (do

73+ debugMessage [TextPart (

74+ show !(gensym "abc") ++

75+ show !(gensym "abc")

76+ )]

77+ )

78+

79+Quasiquotation

80+--------------

81+

82+Since names are used frequently in elaborator reflection there is a shortcut for constructing them:

83+

84+.. list-table::

85+

86+ * - An unresolved variable "x" is wrapped in backtick and double braces:

87+ - .. code-block:: idris

88+

89+ Idris> `{{x}}

90+ UN "x" : TTName

91+

92+

93+ * - Single braces are used for existing variables:

94+ - .. code-block:: idris

95+

96+ Idris> `{x}

97+ No such variable x

98+ Idris> :let x=2

99+ Idris> `{x}

100+ UN "x" : TTName

101+

102+

103+ * - brackets are used for an expression:

104+

105+ here type is inferable

106+ - .. code-block:: idris

107+

108+ Idris> :let a=2

109+ Idris> `(a)

110+ P Ref (UN "a") (TConst (AType (ATInt ITBig))) : TT

111+

112+

113+ * - Expression with explicit type:

114+ - .. code-block:: idris

115+

116+ Idris> `(a:Integer)

117+ P Ref (UN "a") (TConst (AType (ATInt ITBig))) : TT

118+

119+

120+ * - If we want the value we can escape from quasiquotation by using anti-quotation (tilde)

121+ - .. code-block:: idris

122+

123+ Idris> `(~a)

124+ 2 : Integer

125+

126+quasiquotation summary:

127+

128++------------+-----------+----------------------------------------------------------+

129+| |Reification| |

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|

141+| | | than quoted. |

142++------------+-----------+----------------------------------------------------------+

143+|(Var\`{{x}})| Raw | |

144++------------+-----------+----------------------------------------------------------+

145+

146+TT

147+--

148+

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:

151+

152++------------+-------+-------------+---------------------------------------------+

153+| | | Syntax | More Information |

154++============+=======+=============+=============================================+

155+| term | | t | |

156++------------+-------+-------------+---------------------------------------------+

157+| binding | | b | |

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 | |

172+| constructor| | | |

173++------------+-------+-------------+---------------------------------------------+

174+| Data | t ::= | C | |

175+| constructor| | | |

176++------------+-------+-------------+---------------------------------------------+

177+| function | b::= | λ c:t | colon ':' separates parameters from body of |

178+| | | | binding. |

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 | |

189+| literal | | | |

190++------------+-------+-------------+---------------------------------------------+

191+|integer type| c:== | Integer | |

192++------------+-------+-------------+---------------------------------------------+

193+| string | c:== | s | |

194+| literal | | | |

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++------------+-------+-------------+---------------------------------------------+

202+

203+Sometimes the part of the term in focus is underlined.

204+

205+Reflection of the well typed core language

206+

207+.. code-block:: idris

208+

209+ data TT =

210+ ||| A reference to some name (P for Parameter)

211+ P NameType TTName TT |

212+ ||| de Bruijn variables

213+ V Int |

214+ ||| Bind a variable

215+ Bind TTName (Binder TT) TT |

216+ ||| Apply one term to another

217+ App TT TT |

218+ ||| Embed a constant

219+ TConst Const |

220+ ||| Erased terms

221+ Erased |

222+ ||| The type of types along (with universe constraints)

223+ TType TTUExp |

224+ ||| Alternative universes for dealing with uniqueness

225+ UType Universe |

226+

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:

229+

230+- 0=inside current (inner) lambda term

231+- 1= next outer lambda term

232+- 2= next outer and so on

233+

234+Raw

235+---

236+

237+Raw is similar to TT except it is used before types are known. The types should be resolved by the type checker.

238+

239+.. code-block:: idris

240+

241+ data Raw =

242+ ||| Variables, global or local

243+ Var TTName |

244+ ||| Bind a variable

245+ RBind TTName (Binder Raw) Raw |

246+ ||| Application

247+ RApp Raw Raw |

248+ ||| The type of types

249+ RType |

250+ ||| Alternative universes for dealing with uniqueness

251+ RUType Universe |

252+ ||| Embed a constant

253+ RConstant Const |

254+

255+Expression Syntax

256+-----------------

257+

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.

259+

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.

261+

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:

264+

265++---------------+--------+-------------------+

266+| λ a . λ b . f | means | λ a .( λ b . f) |

267++---------------+--------+-------------------+

268+

269+and the same for function application:

270+

271++---------------+--------+-------------------+

272+| f g x | means | f (g x) |

273++---------------+--------+-------------------+

274+

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:

277+

278++-----------------------+

279+| ? {hole_0} . {hole_0} |

280++-----------------------+

281+

282+The term, to be derived, may start off in this state following something like this:

283+

284+.. code-block:: idris

285+

286+ myScript : Elab ()

287+ myScript= do

288+

289+The dot '.' tells us this is some sort of binding.

290+

291++----------------------------------------------+

292+| ?{hole_0} ≈ ? {hole_2} . {hole_2} . {hole_0} |

293++----------------------------------------------+

294+

295+This is a slightly more complicated example arising from:

296+

297+.. code-block:: idris

298+

299+ idNat : Nat -> Nat

300+ idNat = %runElab (do

301+

302+This introduces a guess that hole_0 = hole_2 .

303+

304++----------------------------------------------------+

305+| ?{hole_0} ≈ λ x . ? {hole_2} . {hole_2} . {hole_0} |

306++----------------------------------------------------+

307+

308+Following on from the previous example a lambda function is introduced like this:

309+

310+.. code-block:: idris

311+

312+ intro `{{x}}

313+

314+So now the expression is wrapped in a lambda binding.

315+

316++-------------------------------------------------------+

317+| ?{hole_0} ≈ λ x . ?{hole_2} ≈ x . {hole_2} . {hole_0} |

318++-------------------------------------------------------+

319+

320+Following on, we can use the fill tactic like this:

321+

322+.. code-block:: idris

323+

324+ fill (Var `{{x}})

325+

326+which introduces another guess.

327+

328++--------------------------------+

329+| ?{hole_0} ≈ λ x . x . {hole_0} |

330++--------------------------------+

331+

332+The solve tactic completes the proof

333+

334+Binders

335+-------

336+

337+Here we look at each tactic in turn to see how they affect the proof state.

338+

339+Introduction tactics for binders. The binder types are:

340+

341+- lambda function (intro)

342+- dependent function (forall)

343+- let (letBind)

344+- pattern (patbind)

345+

346+A precondition of these tactics is that the focused hole is of the form:

347+

348++-----------+

349+| ?h : t.h |

350++-----------+

351+

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:

353+

354++--------------------+

355+| ?h : t1 -> t2.f h |

356++--------------------+

357+

358+and a tactic such as

359+

360++------------------+

361+| intro \`{{x}} |

362++------------------+

363+

364+were applied, the result would be the term

365+

366++---------------------------+

367+| ?h : t2 . λ x:t1. f h |

368++---------------------------+

369+

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.

371+

372+.. list-table:: Binders

373+ :widths: 10 30

374+ :stub-columns: 1

375+

376+ * - intro

377+ - Introduce a lambda binding around the current hole and focus on the body.

378+

379+ Requires that the hole be in binding form (use 'attack' if it might not be).

380+

381+ @ n the name to use for the argument.

382+

383+ Signature:

384+

385+ intro : (n : TTName) -> Elab ()

386+

387+ Result

388+

389+ λn:t1.?h:[n/x]t2.h

390+

391+ * - intro'

392+ - Introduce a lambda binding around the current hole and focus on the body, using the name provided by the type of the hole.

393+

394+ Requires that the hole be immediately under its binder (use 'attack' if it might not be).

395+

396+ Signature:

397+

398+ intro' : Elab ()

399+

400+ * - forall

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

402+

403+ (use 'attack' if it might not be).

404+

405+ Signature:

406+

407+ forall : TTName -> Raw -> Elab ()

408+

409+ * - patbind

410+ - Introduce a new pattern binding. Requires that the hole be immediately under its binder (use 'attack' if it might not be).

411+

412+ Signature:

413+

414+ patbind : TTName -> Elab ()

415+

416+ * - letbind

417+ - Introduce a new let binding.

418+

419+ Requires that the hole be immediately under its binder (use 'attack' if it might not be).

420+

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

424+

425+ Signature:

426+

427+ letbind : (n : TTName) -> (ty, tm : Raw) -> Elab ()

428+

429+.. target-notes::

430+.. _`Dependently Typed Functional Programs and their Proofs by McBride 1999`: https://www.era.lib.ed.ac.uk/handle/1842/374

docs/faq/faq.rstnew file+329

@@ -0,0 +1,329 @@

1+**************************

2+Frequently Asked Questions

3+**************************

4+

5+What are the differences between Agda and Idris?

6+================================================

7+

8+Like Idris, Agda is a functional language with dependent types, supporting

9+dependent pattern matching. Both can be used for writing programs and proofs.

10+However, Idris has been designed from the start to emphasise general purpose

11+programming rather than theorem proving. As such, it supports interoperability

12+with systems libraries and C programs, and language constructs for

13+domain specific language implementation. It also includes higher level

14+programming constructs such as interfaces (similar to type classes) and do notation.

15+

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.

19+

20+

21+Is Idris production ready?

22+==========================

23+

24+Idris is primarily a research tool for exploring the possibilities of software

25+development with dependent types, meaning that the primary goal is not (yet) to

26+make a system which could be used in production. As such, there are a few rough

27+corners, and lots of missing libraries. Nobody is working on Idris full time,

28+and we don't have the resources at the moment to polish the system on our own.

29+Therefore, we don't recommend building your business around it!

30+

31+Having said that, contributions which help towards making Idris suitable

32+for use in production would be very welcome - this includes (but is not

33+limited to) extra library support, polishing the run-time system (and ensuring

34+it is robust), providing and maintaining a JVM back end, etc.

35+

36+Is there some documentation for the standard lib? List of functions?

37+=====================================================================

38+

39+API documentation for the shipped packages is listed on `the

40+documentation page <https://www.idris-lang.org/documentation/>`_.

41+

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:

45+

46++ REPL commands:

47+

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.

51+

52++ Use the REPL's auto-complete functionality.

53++ Grep through the source code in `libs/`

54+

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.

59+

60+

61+Why does Idris use eager evaluation rather than lazy?

62+=====================================================

63+

64+Idris uses eager evaluation for more predictable performance, in particular

65+because one of the longer term goals is to be able to write efficient and

66+verified low level code such as device drivers and network infrastructure.

67+Furthermore, the Idris type system allows us to state precisely the type

68+of each value, and therefore the run-time form of each value. In a lazy

69+language, consider a value of type ``Int``:

70+

71+.. code-block:: idris

72+

73+ thing : Int

74+

75+What is the representation of ``thing`` at run-time? Is it a bit pattern

76+representing an integer, or is it a pointer to some code which will compute

77+an integer? In Idris, we have decided that we would like to make this

78+distinction precise, in the type:

79+

80+.. code-block:: idris

81+

82+ thing_val : Int

83+ thing_comp : Lazy Int

84+

85+Here, it is clear from the type that ``thing_val`` is guaranteed to be a

86+concrete ``Int``, whereas ``thing_comp`` is a computation which will produce an

87+``Int``.

88+

89+

90+How can I make lazy control structures?

91+=======================================

92+

93+You can make control structures using the special Lazy type. For

94+example, ``if...then...else...`` in Idris expands to an application of

95+a function named ``ifThenElse``. The default implementation for

96+Booleans is defined as follows in the library:

97+

98+.. code-block:: idris

99+

100+ ifThenElse : Bool -> (t : Lazy a) -> (e : Lazy a) -> a

101+ ifThenElse True t e = t

102+ ifThenElse False t e = e

103+

104+The type ``Lazy a`` for ``t`` and ``e`` indicates that those arguments will

105+only be evaluated if they are used, that is, they are evaluated lazily.

106+

107+

108+Evaluation at the REPL doesn't behave as I expect. What's going on?

109+===================================================================

110+

111+Being a fully dependently typed language, Idris has two phases where it

112+evaluates things, compile-time and run-time. At compile-time it will only

113+evaluate things which it knows to be total (i.e. terminating and covering all

114+possible inputs) in order to keep type checking decidable. The compile-time

115+evaluator is part of the Idris kernel, and is implemented in Haskell using a

116+HOAS (higher order abstract syntax) style representation of values. Since

117+everything is known to have a normal form here, the evaluation strategy doesn't

118+actually matter because either way it will get the same answer, and in practice

119+it will do whatever the Haskell run-time system chooses to do.

120+

121+The REPL, for convenience, uses the compile-time notion of evaluation. As well

122+as being easier to implement (because we have the evaluator available) this can

123+be very useful to show how terms evaluate in the type checker. So you can see

124+the difference between:

125+

126+.. code-block:: idris

127+

128+ Idris> \n, m => (S n) + m

129+ \n => \m => S (plus n m) : Nat -> Nat -> Nat

130+

131+ Idris> \n, m => n + (S m)

132+ \n => \m => plus n (S m) : Nat -> Nat -> Nat

133+

134+

135+Why can't I use a function with no arguments in a type?

136+=======================================================

137+

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:

141+

142+.. code-block:: idris

143+

144+ append : Vect n ty -> Vect m ty -> Vect (n + m) ty

145+

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,

148+you may also have:

149+

150+.. code-block:: idris

151+

152+ ty : Type

153+ ty = String

154+

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...

157+

158+.. code-block:: idris

159+

160+ append : Vect n String -> Vect m String -> Vect (n + m) String

161+

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.

165+

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:

169+

170+.. code-block:: idris

171+

172+ append : Vect n Main.ty -> Vect m Main.ty -> Vect (n + m) Main.ty

173+

174+Alternatively, you can use a name which does not begin with a lower case

175+letter, which will never be implicitly bound:

176+

177+.. code-block:: idris

178+

179+ Ty : Type

180+ Ty = String

181+

182+ append : Vect n Ty -> Vect m Ty -> Vect (n + m) Ty

183+

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.

186+

187+

188+I have an obviously terminating program, but Idris says it possibly isn't total. Why is that?

189+=============================================================================================

190+

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.

198+

199+- Mutually recursive functions are supported

200+

201+- However, all functions on the path must be fully applied. In particular,

202+ higher order applications are not supported

203+

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)``.

209+

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``

212+function.

213+

214+

215+When will Idris be self-hosting?

216+================================

217+

218+It’s not a priority, though not a bad idea in the long run. It would

219+be a worthwhile effort in the short term to implement libraries in

220+Idris to support self-hosting, such as argument parsing and a

221+POSIX-compliant library for system interaction.

222+

223+Does Idris have universe polymorphism? What is the type of ``Type``?

224+====================================================================

225+

226+Rather than universe polymorphism, Idris has a cumulative hierarchy of

227+universes; ``Type : Type 1``, ``Type 1 : Type 2``, etc.

228+Cumulativity means that if ``x : Type n`` and ``n <= m``, then

229+``x : Type m``. Universe levels are always inferred by Idris, and

230+cannot be specified explicitly. The REPL command ``:type Type 1`` will

231+result in an error, as will attempting to specify the universe level

232+of any type.

233+

234+

235+Why does Idris use ``Double`` instead of ``Float64``?

236+=====================================================

237+

238+Historically the C language and many other languages have used the

239+names ``Float`` and ``Double`` to represent floating point numbers of

240+size 32 and 64 respectively. Newer languages such as Rust and Julia

241+have begun to follow the naming scheme described in `IEEE Standard for

242+Floating-Point Arithmetic (IEEE 754)

243+<https://en.wikipedia.org/wiki/IEEE_floating_point>`_. This describes

244+single and double precision numbers as ``Float32`` and ``Float64``;

245+the size is described in the type name.

246+

247+Due to developer familiarity with the older naming convention, and

248+choice by the developers of Idris, Idris uses the C style convention.

249+That is, the name ``Double`` is used to describe double precision

250+numbers, and Idris does not support 32 bit floats at present.

251+

252+

253+What is -ffreestanding?

254+=======================

255+

256+The freestanding flag is used to build Idris binaries which have their

257+libs and compiler in a relative path. This is useful for building binaries

258+where the install directory is unknown at build time. When passing this

259+flag, the IDRIS_LIB_DIR environment variable needs to be set to the path

260+where the Idris libs reside relative to the idris executable. The

261+IDRIS_TOOLCHAIN_DIR environment variable is optional, if that is set,

262+Idris will use that path to find the C compiler. For example:

263+

264+::

265+

266+ IDRIS_LIB_DIR="./libs" \

267+ IDRIS_TOOLCHAIN_DIR="./mingw/bin" \

268+ CABALFLAGS="-fffi -ffreestanding -frelease" \

269+ make

270+

271+

272+What does the name “Idris” mean?

273+================================

274+

275+British people of a certain age may be familiar with this

276+`singing dragon <https://www.youtube.com/watch?v=G5ZMNyscPcg>`_. If

277+that doesn’t help, maybe you can invent a suitable acronym :-) .

278+

279+

280+Will there be support for Unicode characters for operators?

281+===========================================================

282+

283+There are several reasons why we should not support Unicode operators:

284+

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

287+ what they are.

288+

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.

293+

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

296+ with it.

297+

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

300+ brackets.

301+

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.

306+

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.

311+

312+This seems like an instance of `Wadler's

313+Law <https://www.haskell.org/haskellwiki/Wadler%27s_Law>`__ in action.

314+

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>`_.

317+

318+Where can I find the community standards for the Idris community?

319+==================================================================

320+

321+The Idris Community Standards are stated `here

322+<https://www.idris-lang.org/documentation/community-standards/>`_ .

323+

324+Where can I find more answers?

325+==============================

326+

327+There is an `Unofficial FAQ

328+<https://github.com/idris-lang/Idris-dev/wiki/Unofficial-FAQ>`_ on the wiki on

329+GitHub which answers more technical questions and may be updated more often.

docs/guides/index.rstnew file+22

@@ -0,0 +1,22 @@

1+.. _guides-index:

2+

3+################################

4+Tutorials on the Idris Language

5+################################

6+

7+Tutorials submitted by community members.

8+

9+.. note::

10+ The documentation for Idris has been published under the Creative

11+ Commons CC0 License. As such to the extent possible under law, *The

12+ Idris Community* has waived all copyright and related or neighboring

13+ rights to Documentation for Idris.

14+

15+ More information concerning the CC0 can be found online at: https://creativecommons.org/publicdomain/zero/1.0/

16+

17+

18+.. toctree::

19+ :maxdepth: 1

20+

21+ type-providers-ffi

22+ theorem-prover

docs/guides/theorem-prover.rstnew file+217

@@ -0,0 +1,217 @@

1+*******************************

2+The Interactive Theorem Prover

3+*******************************

4+

5+This short guide contributed by a community member illustrates how to prove associativity of addition on ``Nat`` using the interactive theorem prover.

6+

7+First we define a module ``Foo.idr``

8+

9+.. code-block:: idris

10+

11+ module Foo

12+

13+ plusAssoc : plus n (plus m o) = plus (plus n m) o

14+ plusAssoc = ?rhs

15+

16+We wish to perform induction on ``n``. First we load the file into the Idris ``REPL`` as follows::

17+

18+ $ idris Foo.idr

19+

20+We will be given the following prompt, in future releases the version string will differ::

21+

22+ ____ __ _

23+ / _/___/ /____(_)____

24+ / // __ / ___/ / ___/ Version 0.9.18.1

25+ _/ // /_/ / / / (__ ) https://www.idris-lang.org/

26+ /___/\__,_/_/ /_/____/ Type :? for help

27+

28+ Idris is free software with ABSOLUTELY NO WARRANTY.

29+ For details type :warranty.

30+ Type checking ./Foo.idr

31+ Metavariables: Foo.rhs

32+ *Foo>

33+

34+

35+Explore the Context

36+====================

37+

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::

41+

42+ *Foo> :p rhs

43+ ---------- Goal: ----------

44+ { hole 0 }:

45+ (n : Nat) ->

46+ (m : Nat) ->

47+ (o : Nat) ->

48+ plus n (plus m o) = plus (plus n m) o

49+

50+Application of Intros

51+=====================

52+

53+We first apply the ``intros`` tactic::

54+

55+ -Foo.rhs> intros

56+ ---------- Other goals: ----------

57+ { hole 2 }

58+ { hole 1 }

59+ { hole 0 }

60+ ---------- Assumptions: ----------

61+ n : Nat

62+ m : Nat

63+ o : Nat

64+ ---------- Goal: ----------

65+ { hole 3 }:

66+ plus n (plus m o) = plus (plus n m) o

67+

68+Induction on ``n``

69+==================

70+

71+Then apply ``induction`` on to ``n``::

72+

73+ -Foo.rhs> induction n

74+ ---------- Other goals: ----------

75+ elim_S0

76+ { hole 2 }

77+ { hole 1 }

78+ { hole 0 }

79+ ---------- Assumptions: ----------

80+ n : Nat

81+ m : Nat

82+ o : Nat

83+ ---------- Goal: ----------

84+ elim_Z0:

85+ plus Z (plus m o) = plus (plus Z m) o

86+

87+

88+Compute

89+=======

90+

91+::

92+

93+ -Foo.rhs> compute

94+ ---------- Other goals: ----------

95+ elim_S0

96+ { hole 2 }

97+ { hole 1 }

98+ { hole 0 }

99+ ---------- Assumptions: ----------

100+ n : Nat

101+ m : Nat

102+ o : Nat

103+ ---------- Goal: ----------

104+ elim_Z0:

105+ plus m o = plus m o

106+

107+Trivial

108+=======

109+

110+::

111+

112+ -Foo.rhs> trivial

113+ ---------- Other goals: ----------

114+ { hole 2 }

115+ { hole 1 }

116+ { hole 0 }

117+ ---------- Assumptions: ----------

118+ n : Nat

119+ m : Nat

120+ o : Nat

121+ ---------- Goal: ----------

122+ elim_S0:

123+ (n__0 : Nat) ->

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

126+

127+Intros

128+======

129+

130+::

131+

132+ -Foo.rhs> intros

133+ ---------- Other goals: ----------

134+ { hole 4 }

135+ elim_S0

136+ { hole 2 }

137+ { hole 1 }

138+ { hole 0 }

139+ ---------- Assumptions: ----------

140+ n : Nat

141+ m : Nat

142+ o : Nat

143+ n__0 : Nat

144+ ihn__0 : plus n__0 (plus m o) = plus (plus n__0 m) o

145+ ---------- Goal: ----------

146+ { hole 5 }:

147+ plus (S n__0) (plus m o) = plus (plus (S n__0) m) o

148+

149+

150+Compute

151+=======

152+

153+::

154+

155+ -Foo.rhs> compute

156+ ---------- Other goals: ----------

157+ { hole 4 }

158+ elim_S0

159+ { hole 2 }

160+ { hole 1 }

161+ { hole 0 }

162+ ---------- Assumptions: ----------

163+ n : Nat

164+ m : Nat

165+ o : Nat

166+ n__0 : Nat

167+ ihn__0 : plus n__0 (plus m o) = plus (plus n__0 m) o

168+ ---------- Goal: ----------

169+ { hole 5 }:

170+ S (plus n__0 (plus m o)) = S (plus (plus n__0 m) o)

171+

172+

173+Rewrite

174+=======

175+

176+::

177+

178+ -Foo.rhs> rewrite ihn__0

179+ ---------- Other goals: ----------

180+ { hole 5 }

181+ { hole 4 }

182+ elim_S0

183+ { hole 2 }

184+ { hole 1 }

185+ { hole 0 }

186+ ---------- Assumptions: ----------

187+ n : Nat

188+ m : Nat

189+ o : Nat

190+ n__0 : Nat

191+ ihn__0 : plus n__0 (plus m o) = plus (plus n__0 m) o

192+ ---------- Goal: ----------

193+ { hole 6 }:

194+ S (plus n__0 (plus m o)) = S (plus n__0 (plus m o))

195+

196+Trivial

197+=======

198+

199+::

200+

201+ -Foo.rhs> trivial

202+ rhs: No more goals.

203+ -Foo.rhs> qed

204+ Proof completed!

205+ Foo.rhs = proof

206+ intros

207+ induction n

208+ compute

209+ trivial

210+ intros

211+ compute

212+ rewrite ihn__0

213+ trivial

214+

215+Two goals were created: one for ``Z`` and one for ``S``.

216+Here we have proven associativity, and assembled a tactic based proof script.

217+This proof script can be added to ``Foo.idr``.

docs/guides/type-providers-ffi.rstnew file+247

@@ -0,0 +1,247 @@

1+***********************

2+Type Providers in Idris

3+***********************

4+

5+`Type providers in Idris

6+<https://www.davidchristiansen.dk/pubs/dependent-type-providers.pdf>`__

7+are simple enough, but there are a few caveats to using them that it

8+would be worthwhile to go through the basic steps. We also go over

9+foreign functions, because these will often be used with type

10+providers.

11+

12+The use case

13+============

14+

15+First, let's talk about *why* we might want type providers. There are

16+a number of reasons to use them and there are other examples available

17+around the net, but in this tutorial we'll be using them to port C's

18+``struct stat`` to Idris.

19+

20+Why do we need type providers? Well, Idris's FFI needs to know the

21+types of the things it passes to and from C, but the fields of a

22+``struct stat`` are implementation-dependent types that cannot be

23+relied upon. We don't just want to hard-code these types into our

24+program... so we'll use a type provider to find them at compile time!

25+

26+A simple example

27+================

28+

29+First, let's go over a basic usage of type providers, because foreign

30+functions can be confusing but it's important to remember that

31+providers themselves are simple.

32+

33+A type provider is simply an IO action that returns a value of this

34+type:

35+

36+.. code-block:: idris

37+

38+ data Provider a = Provide a | Error String

39+

40+Looks familiar? ``Provider`` is just ``Either a String``, given a

41+slightly more descriptive name.

42+

43+Remember though, type providers we use in our program must be IO

44+actions. Let's write a simple one now:

45+

46+.. code-block:: idris

47+

48+ module Provider

49+ -- Asks nicely for the user to supply the size of C's size_t type on this

50+ -- machine

51+ getSizeT : IO (Provider Int)

52+ getSizeT = do

53+ putStrLn "I'm sorry, I don't know how big size_t is. Can you tell me, in bytes?"

54+ resp <- getLine

55+ case readInt resp of

56+ Just sizeTSize => pure (Provide sizeTSize)

57+ Nothing => pure (Error "I'm sorry, I don't understand.")

58+ -- the readInt function is left as an exercise

59+

60+We assume that whoever's compiling the library knows the size of

61+``size_t``, so we'll just ask them! (Don't worry, we'll get it

62+ourselves later.) Then, if their response can be converted to an

63+integer, we present ``Provide sizeTSize`` as the result of our IO

64+action; or if it can't, we signal a failure. (This will then become a

65+compile-time error.)

66+

67+Now we can use this IO action as a type provider:

68+

69+.. code-block:: idris

70+

71+ module Main

72+ -- to gain access to the IO action we're using as a provider

73+ import Provider

74+

75+ -- TypeProviders is an extension, so we'll enable it

76+ %language TypeProviders

77+

78+ -- And finally, use the provider!

79+ -- Note that the parentheses are mandatory.

80+ %provide (sizeTSize : Int) with getSizeT

81+

82+ -- From now on it's just a normal program where `sizeTSize` is available

83+ -- as a top-level constant

84+ main : IO ()

85+ main = do

86+ putStr "Look! I figured out how big size_t is! It's "

87+ putStr (show sizeTSize)

88+ putStr " bytes!"

89+

90+Yay! We... asked the user something at compile time? That's not very

91+good, actually. Our library is going to be difficult to compile! This

92+is hardly a step up from having them edit in the size of ``size_t``

93+themselves!

94+

95+Don't worry, there's a better way.

96+

97+Foreign Functions

98+=================

99+

100+It's actually pretty easy to write a C function that figures out the

101+size of ``size_t``:

102+

103+.. code:: c

104+

105+ int sizeof_size_t() { return sizeof(size_t); }

106+

107+(Why an int and not a ``size_t``? The FFI needs to know how to receive

108+the return value of this function and translate it into an Idris

109+value. If we knew how to do this for values of C type ``size_t``, we

110+wouldn't need to write this function at all! If we really wanted to be

111+safe from overflow, we could use an array of multiple integers, but

112+the SIZE of ``size_t`` is never going to be a 65535 byte integer.)

113+

114+So now we can get the size of ``size_t`` as long as we're in C code.

115+We'd like to be able to use this from Idris. Can we do this? It turns

116+out we can.

117+

118+``foreign``

119+-------------

120+

121+With foreign, we can turn a C function into an IO action. It works

122+like this:

123+

124+.. code-block:: idris

125+

126+ getSizeT : IO Int

127+ getSizeT = foreign FFI_C "sizeof_size_t" (IO Int)

128+

129+Pretty simple. ``foreign`` takes a specification of what function it

130+needs to call and that function's return type.

131+

132+Running foreign functions

133+-------------------------

134+

135+This is all well and good for writing code that will typecheck. To

136+actually run the code, we'll need to do just a bit more work. Exactly

137+what we need to do depends on whether we want to interpret or compile

138+our code.

139+

140+In the interpreter

141+------------------

142+

143+If we want to call our foreign functions from interpreted code (such

144+as the REPL or a type provider), we need to dynamically link a library

145+containing the symbols we need. This is pretty easy to do with the

146+``%dynamic`` directive:

147+

148+.. code-block:: idris

149+

150+ %dynamic "./filename.so"

151+

152+Note that the leading "./" is important: currently, the string you

153+provide is interpreted as by ``dlopen()``, which on Unix does not search

154+in the current directory by default. If you use the "./", the library

155+will be searched for in the directory from which you run idris (*not*

156+the location of the file you're running!). Of course, if you're using

157+functions from an installed library rather than something you wrote

158+yourself, the "./" is not necessary.

159+

160+In an executable

161+----------------

162+

163+If we want to run our code from an executable, we can statically link

164+instead. We'll use the ``%include`` and ``%link`` directives:

165+

166+.. code-block:: idris

167+

168+ %include C "filename.h"

169+ %link C "filename.o"

170+

171+Note the extra argument to the directive! We specify that we're

172+linking a C header and library. Also, unlike ``%dynamic``, these

173+directives search in the current directory by default. (That is, the

174+directory from which we run idris.)

175+

176+Putting it all together

177+=======================

178+

179+So, at the beginning of this article I said we'd use type providers to

180+port ``struct stat`` to Idris. The relevant part is just translating

181+all the mysterious typedef'd C types into Idris types, and that's what

182+we'll do here.

183+

184+First, let's write a C file containing functions that we'll bind to.

185+

186+.. code-block:: c

187+

188+ /* stattypes.c */

189+ #include <sys/stat.h>

190+

191+ int sizeof_dev_t() { return sizeof(dev_t); }

192+ int sizeof_ino_t() { return sizeof(ino_t); }

193+ /* lots more functions like this */

194+

195+Next, an Idris file to define our providers:

196+

197+.. code-block:: idris

198+

199+ -- Providers.idr

200+ module Providers

201+

202+ %dynamic "./stattypes.so"

203+ %access export

204+

205+ sizeOfDevT : IO Int

206+ sizeOfDevT = foreign FFI_C "sizeof_dev_t" (IO Int)

207+ {- lots of similar functions -}

208+

209+ -- Indicates how many bits are used to represent various system

210+ -- stat types.

211+ public export

212+ data BitWidth = B8 | B16 | B32 | B64

213+

214+ Show BitWidth where

215+ show B8 = "8 bits"

216+ show B16 = "16 bits"

217+ show B32 = "32 bits"

218+ show B64 = "64 bits"

219+

220+ -- Now we have an integer, but we want a Provider BitWidth.

221+ -- Since our sizeOf* functions are ordinary IO actions, we

222+ -- can just map over them.

223+ bytesToType : Int -> Provider BitWidth

224+ bytesToType 1 = Provide B8 -- "8 bit value"

225+ bytesToType 2 = Provide B16

226+ bytesToType 4 = Provide B32

227+ bytesToType 8 = Provide B64

228+ bytesToType _ = Error "Unrecognised integral type."

229+

230+ getDevT : IO (Provider BitWidth)

231+ getDevT = map bytesToType sizeOfDevT

232+ {- lots of similar functions -}

233+

234+Finally, we'll write one more idris file where we use the type

235+providers:

236+

237+.. code-block:: idris

238+

239+ -- Main.idr

240+ module Main

241+ import Providers

242+ %language TypeProviders

243+ %provide (DevTBitWidth : BitWidth) with getDevT

244+

245+ -- We can now use DevTBitWidth in our program!

246+ main : IO ()

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:

2+

3+* The SVG file, being vector graphics, is best for drawing and modifying.

4+* The PNG file, being raster graphics, gives more consistent rendering.

5+

6+The image has therefore been generated as an SVG file and then exported to the PNG file.

7+

8+So, if you need to modify an image, I suggest the following sequence:

9+

10+* Edit the SVG file using a suitable editor (I use Inkscape).

11+* Export the changes to the PNG file, overwriting the old version.

12+* upload both files.

13+

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 210 297"

15+ version="1.1"

16+ id="svg8"

17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"

18+ sodipodi:docname="attack.svg">

19+ <defs

20+ id="defs2">

21+ <marker

22+ inkscape:stockid="Arrow1Mend"

23+ orient="auto"

24+ refY="0.0"

25+ refX="0.0"

26+ id="marker890"

27+ style="overflow:visible;"

28+ inkscape:isstock="true">

29+ <path

30+ id="path888"

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)" />

34+ </marker>

35+ <marker

36+ inkscape:isstock="true"

37+ style="overflow:visible;"

38+ id="marker838"

39+ refX="0.0"

40+ refY="0.0"

41+ orient="auto"

42+ inkscape:stockid="Arrow1Mend"

43+ inkscape:collect="always">

44+ <path

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 "

48+ id="path836" />

49+ </marker>

50+ <marker

51+ inkscape:stockid="Arrow1Mend"

52+ orient="auto"

53+ refY="0.0"

54+ refX="0.0"

55+ id="Arrow1Mend"

56+ style="overflow:visible;"

57+ inkscape:isstock="true"

58+ inkscape:collect="always">

59+ <path

60+ id="path4529"

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)" />

64+ </marker>

65+ </defs>

66+ <sodipodi:namedview

67+ id="base"

68+ pagecolor="#ffffff"

69+ bordercolor="#666666"

70+ borderopacity="1.0"

71+ inkscape:pageopacity="0.0"

72+ inkscape:pageshadow="2"

73+ inkscape:zoom="1"

74+ inkscape:cx="313.5"

75+ inkscape:cy="696.5"

76+ inkscape:document-units="mm"

77+ inkscape:current-layer="layer1"

78+ showgrid="false"

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" />

84+ <metadata

85+ id="metadata5">

86+ <rdf:RDF>

87+ <cc:Work

88+ rdf:about="">

89+ <dc:format>image/svg+xml</dc:format>

90+ <dc:type

91+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

92+ <dc:title />

93+ </cc:Work>

94+ </rdf:RDF>

95+ </metadata>

96+ <g

97+ inkscape:label="Layer 1"

98+ inkscape:groupmode="layer"

99+ id="layer1">

100+ <rect

101+ style="fill:#ffff00;fill-opacity:1;stroke-width:0.26458332"

102+ id="rect22"

103+ width="28.839582"

104+ height="6.0854182"

105+ x="66.67498"

106+ y="114.4375"

107+ inkscape:export-xdpi="61.120499"

108+ inkscape:export-ydpi="61.120499" />

109+ <text

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"

112+ x="65.352081"

113+ y="105.17709"

114+ id="text12"

115+ inkscape:export-xdpi="61.120499"

116+ inkscape:export-ydpi="61.120499"><tspan

117+ sodipodi:role="line"

118+ x="65.352081"

119+ y="105.17709"

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>

122+ <text

123+ id="text16"

124+ y="118.67083"

125+ x="56.356247"

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"

131+ y="118.67083"

132+ x="56.356247"

133+ id="tspan14"

134+ sodipodi:role="line">?h ≈ (?h' ∶ t1→t2 . h')∶ t1→t2 . f h</tspan></text>

135+ <text

136+ id="text20"

137+ y="110.99791"

138+ x="82.814583"

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"

144+ y="110.99791"

145+ x="82.814583"

146+ id="tspan18"

147+ sodipodi:role="line">attack</tspan></text>

148+ <path

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"

151+ id="path4518"

152+ inkscape:connector-curvature="0"

153+ sodipodi:nodetypes="cc"

154+ inkscape:export-xdpi="61.120499"

155+ inkscape:export-ydpi="61.120499" />

156+ <text

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"

161+ x="63.235413"

162+ y="94.85833"

163+ id="text832"><tspan

164+ sodipodi:role="line"

165+ id="tspan830"

166+ x="63.235413"

167+ y="94.85833"

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>

169+ <path

170+ inkscape:export-ydpi="61.120499"

171+ inkscape:export-xdpi="61.120499"

172+ sodipodi:nodetypes="cc"

173+ inkscape:connector-curvature="0"

174+ id="path834"

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)" />

177+ <text

178+ id="text884"

179+ y="110.23682"

180+ x="61.94511"

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"

186+ y="110.23682"

187+ x="61.94511"

188+ id="tspan882"

189+ sodipodi:role="line">focus</tspan></text>

190+ <path

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"

193+ id="path886"

194+ inkscape:connector-curvature="0"

195+ sodipodi:nodetypes="cc"

196+ inkscape:export-xdpi="61.120499"

197+ inkscape:export-ydpi="61.120499" />

198+ </g>

199+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="binders.svg">

19+ <defs

20+ id="defs4" />

21+ <sodipodi:namedview

22+ id="base"

23+ pagecolor="#ffffff"

24+ bordercolor="#666666"

25+ borderopacity="1.0"

26+ inkscape:pageopacity="0.0"

27+ inkscape:pageshadow="2"

28+ inkscape:zoom="1"

29+ inkscape:cx="255.00889"

30+ inkscape:cy="520"

31+ inkscape:document-units="px"

32+ inkscape:current-layer="layer1"

33+ showgrid="false"

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" />

39+ <metadata

40+ id="metadata7">

41+ <rdf:RDF>

42+ <cc:Work

43+ rdf:about="">

44+ <dc:format>image/svg+xml</dc:format>

45+ <dc:type

46+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

47+ <dc:title></dc:title>

48+ </cc:Work>

49+ </rdf:RDF>

50+ </metadata>

51+ <g

52+ inkscape:label="Layer 1"

53+ inkscape:groupmode="layer"

54+ id="layer1">

55+ <text

56+ xml:space="preserve"

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;"

58+ x="157"

59+ y="177.3622"

60+ id="text4136"

61+ sodipodi:linespacing="125%"

62+ inkscape:export-xdpi="61.120499"

63+ inkscape:export-ydpi="61.120499"><tspan

64+ sodipodi:role="line"

65+ id="tspan4138"

66+ x="157"

67+ y="177.3622"

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>

69+ <text

70+ sodipodi:linespacing="125%"

71+ id="text4140"

72+ y="177.3622"

73+ x="287"

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;"

75+ xml:space="preserve"

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;"

79+ y="177.3622"

80+ x="287"

81+ id="tspan4142"

82+ sodipodi:role="line">Logic</tspan></text>

83+ <path

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"

86+ id="path4144"

87+ inkscape:connector-curvature="0"

88+ sodipodi:nodetypes="cc"

89+ inkscape:export-xdpi="61.120499"

90+ inkscape:export-ydpi="61.120499" />

91+ <path

92+ inkscape:connector-curvature="0"

93+ id="path4146"

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" />

99+ <path

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"

102+ id="path4148"

103+ inkscape:connector-curvature="0"

104+ sodipodi:nodetypes="cc"

105+ inkscape:export-xdpi="61.120499"

106+ inkscape:export-ydpi="61.120499" />

107+ <path

108+ inkscape:connector-curvature="0"

109+ id="path4150"

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" />

115+ <path

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"

118+ id="path4152"

119+ inkscape:connector-curvature="0"

120+ sodipodi:nodetypes="cc"

121+ inkscape:export-xdpi="61.120499"

122+ inkscape:export-ydpi="61.120499" />

123+ <text

124+ sodipodi:linespacing="125%"

125+ id="text4154"

126+ y="235.3622"

127+ x="19"

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'"

133+ y="235.3622"

134+ x="19"

135+ id="tspan4156"

136+ sodipodi:role="line">Abstraction</tspan></text>

137+ <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"

140+ x="19"

141+ y="399.36218"

142+ id="text4158"

143+ sodipodi:linespacing="125%"

144+ inkscape:export-xdpi="61.120499"

145+ inkscape:export-ydpi="61.120499"><tspan

146+ sodipodi:role="line"

147+ id="tspan4160"

148+ x="19"

149+ y="399.36218"

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"

152+ x="19"

153+ y="424.36218"

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>

156+ <text

157+ sodipodi:linespacing="125%"

158+ id="text4162"

159+ y="307.36218"

160+ x="19"

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'"

166+ y="307.36218"

167+ x="19"

168+ id="tspan4164"

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'"

171+ y="332.36218"

172+ x="19"

173+ sodipodi:role="line"

174+ id="tspan4166">space</tspan></text>

175+ <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;"

178+ x="167"

179+ y="235.3622"

180+ id="text4168"

181+ sodipodi:linespacing="125%"

182+ inkscape:export-xdpi="61.120499"

183+ inkscape:export-ydpi="61.120499"><tspan

184+ sodipodi:role="line"

185+ id="tspan4170"

186+ x="167"

187+ y="235.3622"

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>

189+ <text

190+ sodipodi:linespacing="125%"

191+ id="text4172"

192+ y="222.3622"

193+ x="259"

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;"

199+ y="222.3622"

200+ x="259"

201+ id="tspan4174"

202+ sodipodi:role="line">Γ ⊢ S : Type</tspan></text>

203+ <text

204+ sodipodi:linespacing="125%"

205+ id="text4180"

206+ y="417.36218"

207+ x="124"

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;"

213+ y="417.36218"

214+ x="124"

215+ id="tspan4182"

216+ sodipodi:role="line">let x ↦ t : t</tspan></text>

217+ <path

218+ inkscape:connector-curvature="0"

219+ id="path4186"

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" />

225+ <text

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;"

228+ x="246"

229+ y="248.3622"

230+ id="text4188"

231+ sodipodi:linespacing="125%"

232+ inkscape:export-xdpi="61.120499"

233+ inkscape:export-ydpi="61.120499"><tspan

234+ sodipodi:role="line"

235+ id="tspan4190"

236+ x="246"

237+ y="248.3622"

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>

239+ <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;"

242+ x="257"

243+ y="308.36218"

244+ id="text4192"

245+ sodipodi:linespacing="125%"

246+ inkscape:export-xdpi="61.120499"

247+ inkscape:export-ydpi="61.120499"><tspan

248+ sodipodi:role="line"

249+ id="tspan4194"

250+ x="257"

251+ y="308.36218"

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>

253+ <path

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"

257+ id="path4196"

258+ inkscape:connector-curvature="0"

259+ inkscape:export-xdpi="61.120499"

260+ inkscape:export-ydpi="61.120499" />

261+ <text

262+ sodipodi:linespacing="125%"

263+ id="text4198"

264+ y="334.36218"

265+ x="244"

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;"

271+ y="334.36218"

272+ x="244"

273+ id="tspan4200"

274+ sodipodi:role="line">Γ ; ∀ x:S ⊢ valid</tspan></text>

275+ <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;"

278+ x="167"

279+ y="323.36218"

280+ id="text4202"

281+ sodipodi:linespacing="125%"

282+ inkscape:export-xdpi="61.120499"

283+ inkscape:export-ydpi="61.120499"><tspan

284+ sodipodi:role="line"

285+ id="tspan4204"

286+ x="167"

287+ y="323.36218"

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>

289+ <text

290+ sodipodi:linespacing="125%"

291+ id="text4206"

292+ y="402.36218"

293+ x="255"

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;"

299+ y="402.36218"

300+ x="255"

301+ id="tspan4208"

302+ sodipodi:role="line">Γ ⊢ S : Type Γ ⊢ s:S </tspan></text>

303+ <path

304+ inkscape:connector-curvature="0"

305+ id="path4210"

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" />

311+ <text

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;"

314+ x="242"

315+ y="428.36218"

316+ id="text4212"

317+ sodipodi:linespacing="125%"

318+ inkscape:export-xdpi="61.120499"

319+ inkscape:export-ydpi="61.120499"><tspan

320+ sodipodi:role="line"

321+ id="tspan4214"

322+ x="242"

323+ y="428.36218"

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>

325+ </g>

326+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="compareToProofAssist.svg">

19+ <defs

20+ id="defs4">

21+ <marker

22+ inkscape:isstock="true"

23+ style="overflow:visible;"

24+ id="marker4251"

25+ refX="0.0"

26+ refY="0.0"

27+ orient="auto"

28+ inkscape:stockid="Arrow1Mend">

29+ <path

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 "

33+ id="path4253" />

34+ </marker>

35+ <marker

36+ inkscape:stockid="Arrow1Mend"

37+ orient="auto"

38+ refY="0.0"

39+ refX="0.0"

40+ id="marker5018"

41+ style="overflow:visible;"

42+ inkscape:isstock="true">

43+ <path

44+ id="path5020"

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)" />

48+ </marker>

49+ <marker

50+ inkscape:isstock="true"

51+ style="overflow:visible;"

52+ id="marker4436"

53+ refX="0.0"

54+ refY="0.0"

55+ orient="auto"

56+ inkscape:stockid="Arrow1Mend"

57+ inkscape:collect="always">

58+ <path

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 "

62+ id="path4438" />

63+ </marker>

64+ <marker

65+ inkscape:stockid="Arrow1Mend"

66+ orient="auto"

67+ refY="0.0"

68+ refX="0.0"

69+ id="Arrow1Mend"

70+ style="overflow:visible;"

71+ inkscape:isstock="true"

72+ inkscape:collect="always">

73+ <path

74+ id="path4167"

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)" />

78+ </marker>

79+ </defs>

80+ <sodipodi:namedview

81+ id="base"

82+ pagecolor="#ffffff"

83+ bordercolor="#666666"

84+ borderopacity="1.0"

85+ inkscape:pageopacity="0.0"

86+ inkscape:pageshadow="2"

87+ inkscape:zoom="1"

88+ inkscape:cx="377.89372"

89+ inkscape:cy="520"

90+ inkscape:document-units="px"

91+ inkscape:current-layer="layer1"

92+ showgrid="false"

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" />

98+ <metadata

99+ id="metadata7">

100+ <rdf:RDF>

101+ <cc:Work

102+ rdf:about="">

103+ <dc:format>image/svg+xml</dc:format>

104+ <dc:type

105+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

106+ <dc:title />

107+ </cc:Work>

108+ </rdf:RDF>

109+ </metadata>

110+ <g

111+ inkscape:label="Layer 1"

112+ inkscape:groupmode="layer"

113+ id="layer1">

114+ <text

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"

117+ x="162"

118+ y="326.36221"

119+ id="text4136"

120+ sodipodi:linespacing="125%"

121+ inkscape:export-xdpi="61.120499"

122+ inkscape:export-ydpi="61.120499"><tspan

123+ sodipodi:role="line"

124+ id="tspan4138"

125+ x="162"

126+ y="326.36221"

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>

128+ <text

129+ sodipodi:linespacing="125%"

130+ id="text4140"

131+ y="368.36221"

132+ x="162"

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'"

138+ y="368.36221"

139+ x="162"

140+ id="tspan4142"

141+ sodipodi:role="line">Tactics</tspan></text>

142+ <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"

145+ x="161"

146+ y="415.36221"

147+ id="text4144"

148+ sodipodi:linespacing="125%"

149+ inkscape:export-xdpi="61.120499"

150+ inkscape:export-ydpi="61.120499"><tspan

151+ sodipodi:role="line"

152+ id="tspan4146"

153+ x="161"

154+ y="415.36221"

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>

156+ <text

157+ sodipodi:linespacing="125%"

158+ id="text4148"

159+ y="282.36221"

160+ x="130"

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;"

166+ y="282.36221"

167+ x="130"

168+ id="tspan4150"

169+ sodipodi:role="line">Proof assistant</tspan></text>

170+ <path

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"

173+ id="path4152"

174+ inkscape:connector-curvature="0"

175+ inkscape:export-xdpi="61.120499"

176+ inkscape:export-ydpi="61.120499" />

177+ <path

178+ inkscape:connector-curvature="0"

179+ id="path4434"

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" />

184+ <text

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"

187+ x="314"

188+ y="326.36221"

189+ id="text5002"

190+ sodipodi:linespacing="125%"

191+ inkscape:export-xdpi="61.120499"

192+ inkscape:export-ydpi="61.120499"><tspan

193+ sodipodi:role="line"

194+ id="tspan5004"

195+ x="314"

196+ y="326.36221"

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>

198+ <text

199+ sodipodi:linespacing="125%"

200+ id="text5006"

201+ y="413.36221"

202+ x="281"

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'"

208+ y="413.36221"

209+ x="281"

210+ id="tspan5008"

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'"

213+ y="432.11221"

214+ x="281"

215+ sodipodi:role="line"

216+ id="tspan5060">(implicit variables, etc)</tspan></text>

217+ <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"

220+ x="294"

221+ y="282.36221"

222+ id="text5010"

223+ sodipodi:linespacing="125%"

224+ inkscape:export-xdpi="61.120499"

225+ inkscape:export-ydpi="61.120499"><tspan

226+ sodipodi:role="line"

227+ id="tspan5012"

228+ x="294"

229+ y="282.36221"

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>

231+ <path

232+ inkscape:connector-curvature="0"

233+ id="path5014"

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" />

238+ <path

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"

241+ id="path5016"

242+ inkscape:connector-curvature="0"

243+ inkscape:export-xdpi="61.120499"

244+ inkscape:export-ydpi="61.120499" />

245+ <text

246+ inkscape:export-ydpi="61.120499"

247+ inkscape:export-xdpi="61.120499"

248+ sodipodi:linespacing="125%"

249+ id="text4247"

250+ y="369.36221"

251+ x="317"

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'"

255+ y="369.36221"

256+ x="317"

257+ id="tspan4249"

258+ sodipodi:role="line">Tactics</tspan></text>

259+ </g>

260+</svg>

docs/image/effects-tree.pngnew file

Binary file not shown.

docs/image/elab.pngnew file

Binary file not shown.

docs/image/elab.svgnew file+139

@@ -0,0 +1,139 @@

1+<?xml version="1.0" encoding="UTF-8" standalone="no"?>

2+<!-- Created with Inkscape (http://www.inkscape.org/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="elab.svg">

19+ <defs

20+ id="defs4">

21+ <marker

22+ inkscape:stockid="Arrow1Mend"

23+ orient="auto"

24+ refY="0.0"

25+ refX="0.0"

26+ id="Arrow1Mend"

27+ style="overflow:visible;"

28+ inkscape:isstock="true">

29+ <path

30+ id="path4155"

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)" />

34+ </marker>

35+ </defs>

36+ <sodipodi:namedview

37+ id="base"

38+ pagecolor="#ffffff"

39+ bordercolor="#666666"

40+ borderopacity="1.0"

41+ inkscape:pageopacity="0.0"

42+ inkscape:pageshadow="2"

43+ inkscape:zoom="1"

44+ inkscape:cx="381.03373"

45+ inkscape:cy="520"

46+ inkscape:document-units="px"

47+ inkscape:current-layer="layer1"

48+ showgrid="false"

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" />

54+ <metadata

55+ id="metadata7">

56+ <rdf:RDF>

57+ <cc:Work

58+ rdf:about="">

59+ <dc:format>image/svg+xml</dc:format>

60+ <dc:type

61+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

62+ <dc:title></dc:title>

63+ </cc:Work>

64+ </rdf:RDF>

65+ </metadata>

66+ <g

67+ inkscape:label="Layer 1"

68+ inkscape:groupmode="layer"

69+ id="layer1">

70+ <rect

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"

72+ id="rect4136"

73+ width="206"

74+ height="77"

75+ x="236"

76+ y="254.3622"

77+ inkscape:export-xdpi="61.120499"

78+ inkscape:export-ydpi="61.120499" />

79+ <rect

80+ y="388.36218"

81+ x="236"

82+ height="77"

83+ width="206"

84+ id="rect4138"

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" />

88+ <path

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"

91+ id="path4140"

92+ inkscape:connector-curvature="0"

93+ sodipodi:nodetypes="cc"

94+ inkscape:export-xdpi="61.120499"

95+ inkscape:export-ydpi="61.120499" />

96+ <text

97+ xml:space="preserve"

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"

99+ x="242"

100+ y="271.36221"

101+ id="text5334"

102+ sodipodi:linespacing="125%"

103+ inkscape:export-xdpi="61.120499"

104+ inkscape:export-ydpi="61.120499"><tspan

105+ sodipodi:role="line"

106+ id="tspan5336"

107+ x="242"

108+ y="271.36221"

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>

110+ <text

111+ sodipodi:linespacing="125%"

112+ id="text5338"

113+ y="308.36221"

114+ x="253"

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'"

120+ y="308.36221"

121+ x="253"

122+ id="tspan5340"

123+ sodipodi:role="line">definition context</tspan></text>

124+ <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"

127+ x="243"

128+ y="409.36221"

129+ id="text5342"

130+ sodipodi:linespacing="125%"

131+ inkscape:export-xdpi="61.120499"

132+ inkscape:export-ydpi="61.120499"><tspan

133+ sodipodi:role="line"

134+ id="tspan5344"

135+ x="243"

136+ y="409.36221"

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>

138+ </g>

139+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

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">

22+ <defs

23+ id="defs4" />

24+ <sodipodi:namedview

25+ id="base"

26+ pagecolor="#ffffff"

27+ bordercolor="#666666"

28+ borderopacity="1.0"

29+ inkscape:pageopacity="0.0"

30+ inkscape:pageshadow="2"

31+ inkscape:zoom="1"

32+ inkscape:cx="97.25613"

33+ inkscape:cy="593.17666"

34+ inkscape:document-units="px"

35+ inkscape:current-layer="layer1"

36+ showgrid="false"

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" />

42+ <metadata

43+ id="metadata7">

44+ <rdf:RDF>

45+ <cc:Work

46+ rdf:about="">

47+ <dc:format>image/svg+xml</dc:format>

48+ <dc:type

49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

50+ <dc:title />

51+ </cc:Work>

52+ </rdf:RDF>

53+ </metadata>

54+ <g

55+ inkscape:label="Layer 1"

56+ inkscape:groupmode="layer"

57+ id="layer1">

58+ <text

59+ id="text4800"

60+ y="473.36218"

61+ x="205"

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"

63+ xml:space="preserve"

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'"

67+ y="473.36218"

68+ x="205"

69+ sodipodi:role="line"

70+ id="tspan4812">hole_2 : pi_arg : Nat -&gt; Nat</tspan></text>

71+ <text

72+ inkscape:export-ydpi="61.120499"

73+ inkscape:export-xdpi="61.120499"

74+ xml:space="preserve"

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"

76+ x="428.125"

77+ y="472.23718"

78+ id="text4178"><tspan

79+ id="tspan4180"

80+ sodipodi:role="line"

81+ x="428.125"

82+ y="472.23718"

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 -&gt; Nat</tspan></text>

84+ <path

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"

87+ id="path4182"

88+ inkscape:connector-curvature="0"

89+ inkscape:export-xdpi="61.120499"

90+ inkscape:export-ydpi="61.120499" />

91+ <path

92+ inkscape:connector-curvature="0"

93+ id="path4184"

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" />

98+ </g>

99+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

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">

22+ <defs

23+ id="defs4" />

24+ <sodipodi:namedview

25+ id="base"

26+ pagecolor="#ffffff"

27+ bordercolor="#666666"

28+ borderopacity="1.0"

29+ inkscape:pageopacity="0.0"

30+ inkscape:pageshadow="2"

31+ inkscape:zoom="1"

32+ inkscape:cx="425.25613"

33+ inkscape:cy="593.17666"

34+ inkscape:document-units="px"

35+ inkscape:current-layer="layer1"

36+ showgrid="false"

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" />

42+ <metadata

43+ id="metadata7">

44+ <rdf:RDF>

45+ <cc:Work

46+ rdf:about="">

47+ <dc:format>image/svg+xml</dc:format>

48+ <dc:type

49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

50+ <dc:title />

51+ </cc:Work>

52+ </rdf:RDF>

53+ </metadata>

54+ <g

55+ inkscape:label="Layer 1"

56+ inkscape:groupmode="layer"

57+ id="layer1">

58+ <text

59+ id="text4800"

60+ y="473.36218"

61+ x="205"

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"

63+ xml:space="preserve"

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'"

67+ y="473.36218"

68+ x="205"

69+ sodipodi:role="line"

70+ id="tspan4812">hole_2 : Nat</tspan></text>

71+ <text

72+ inkscape:export-ydpi="61.120499"

73+ inkscape:export-xdpi="61.120499"

74+ xml:space="preserve"

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"

76+ x="422.5"

77+ y="472.23718"

78+ id="text4178"><tspan

79+ id="tspan4180"

80+ sodipodi:role="line"

81+ x="422.5"

82+ y="472.23718"

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) -&gt; Nat</tspan></text>

84+ <path

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"

87+ id="path4182"

88+ inkscape:connector-curvature="0"

89+ inkscape:export-xdpi="61.120499"

90+ inkscape:export-ydpi="61.120499" />

91+ <path

92+ inkscape:connector-curvature="0"

93+ id="path4184"

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" />

98+ <text

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"

103+ x="229"

104+ y="447.36218"

105+ id="text4147"><tspan

106+ id="tspan4149"

107+ sodipodi:role="line"

108+ x="229"

109+ y="447.36218"

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>

111+ </g>

112+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

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">

22+ <defs

23+ id="defs4" />

24+ <sodipodi:namedview

25+ id="base"

26+ pagecolor="#ffffff"

27+ bordercolor="#666666"

28+ borderopacity="1.0"

29+ inkscape:pageopacity="0.0"

30+ inkscape:pageshadow="2"

31+ inkscape:zoom="1"

32+ inkscape:cx="425.25613"

33+ inkscape:cy="593.17666"

34+ inkscape:document-units="px"

35+ inkscape:current-layer="layer1"

36+ showgrid="false"

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" />

42+ <metadata

43+ id="metadata7">

44+ <rdf:RDF>

45+ <cc:Work

46+ rdf:about="">

47+ <dc:format>image/svg+xml</dc:format>

48+ <dc:type

49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

50+ <dc:title />

51+ </cc:Work>

52+ </rdf:RDF>

53+ </metadata>

54+ <g

55+ inkscape:label="Layer 1"

56+ inkscape:groupmode="layer"

57+ id="layer1">

58+ <text

59+ id="text4800"

60+ y="473.36218"

61+ x="205"

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"

63+ xml:space="preserve"

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'"

67+ y="473.36218"

68+ x="205"

69+ sodipodi:role="line"

70+ id="tspan4812">hole_2 : Nat</tspan></text>

71+ <text

72+ inkscape:export-ydpi="61.120499"

73+ inkscape:export-xdpi="61.120499"

74+ xml:space="preserve"

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"

76+ x="439.375"

77+ y="472.23718"

78+ id="text4178"><tspan

79+ id="tspan4180"

80+ sodipodi:role="line"

81+ x="439.375"

82+ y="472.23718"

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) -&gt; Nat</tspan></text>

84+ <path

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"

87+ id="path4182"

88+ inkscape:connector-curvature="0"

89+ inkscape:export-xdpi="61.120499"

90+ inkscape:export-ydpi="61.120499" />

91+ <path

92+ inkscape:connector-curvature="0"

93+ id="path4184"

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" />

98+ <text

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"

103+ x="229"

104+ y="447.36218"

105+ id="text4147"><tspan

106+ id="tspan4149"

107+ sodipodi:role="line"

108+ x="229"

109+ y="447.36218"

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>

111+ </g>

112+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

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">

22+ <defs

23+ id="defs4" />

24+ <sodipodi:namedview

25+ id="base"

26+ pagecolor="#ffffff"

27+ bordercolor="#666666"

28+ borderopacity="1.0"

29+ inkscape:pageopacity="0.0"

30+ inkscape:pageshadow="2"

31+ inkscape:zoom="1"

32+ inkscape:cx="425.25613"

33+ inkscape:cy="593.17666"

34+ inkscape:document-units="px"

35+ inkscape:current-layer="layer1"

36+ showgrid="false"

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" />

42+ <metadata

43+ id="metadata7">

44+ <rdf:RDF>

45+ <cc:Work

46+ rdf:about="">

47+ <dc:format>image/svg+xml</dc:format>

48+ <dc:type

49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

50+ <dc:title />

51+ </cc:Work>

52+ </rdf:RDF>

53+ </metadata>

54+ <g

55+ inkscape:label="Layer 1"

56+ inkscape:groupmode="layer"

57+ id="layer1">

58+ <text

59+ inkscape:export-ydpi="61.120499"

60+ inkscape:export-xdpi="61.120499"

61+ xml:space="preserve"

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"

63+ x="205"

64+ y="500.36218"

65+ id="text4178"

66+ sodipodi:linespacing="125%"><tspan

67+ id="tspan4180"

68+ sodipodi:role="line"

69+ x="205"

70+ y="500.36218"

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) -&gt; Nat</tspan></text>

72+ <path

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"

75+ id="path4182"

76+ inkscape:connector-curvature="0"

77+ inkscape:export-xdpi="61.120499"

78+ inkscape:export-ydpi="61.120499" />

79+ </g>

80+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

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">

22+ <defs

23+ id="defs4">

24+ <marker

25+ inkscape:stockid="Arrow1Mend"

26+ orient="auto"

27+ refY="0.0"

28+ refX="0.0"

29+ id="marker4738"

30+ style="overflow:visible;"

31+ inkscape:isstock="true">

32+ <path

33+ id="path4491"

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)" />

37+ </marker>

38+ <marker

39+ inkscape:stockid="Arrow1Mend"

40+ orient="auto"

41+ refY="0.0"

42+ refX="0.0"

43+ id="marker4672"

44+ style="overflow:visible;"

45+ inkscape:isstock="true">

46+ <path

47+ id="path4425"

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)" />

51+ </marker>

52+ <marker

53+ inkscape:stockid="Arrow1Mend"

54+ orient="auto"

55+ refY="0.0"

56+ refX="0.0"

57+ id="Arrow1Mend"

58+ style="overflow:visible;"

59+ inkscape:isstock="true">

60+ <path

61+ id="path4418"

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)" />

65+ </marker>

66+ <marker

67+ inkscape:stockid="Arrow1Mend"

68+ orient="auto"

69+ refY="0"

70+ refX="0"

71+ id="marker5018"

72+ style="overflow:visible"

73+ inkscape:isstock="true">

74+ <path

75+ inkscape:connector-curvature="0"

76+ id="path5020"

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)" />

80+ </marker>

81+ </defs>

82+ <sodipodi:namedview

83+ id="base"

84+ pagecolor="#ffffff"

85+ bordercolor="#666666"

86+ borderopacity="1.0"

87+ inkscape:pageopacity="0.0"

88+ inkscape:pageshadow="2"

89+ inkscape:zoom="1"

90+ inkscape:cx="258.17464"

91+ inkscape:cy="544.34419"

92+ inkscape:document-units="px"

93+ inkscape:current-layer="layer1"

94+ showgrid="false"

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" />

100+ <metadata

101+ id="metadata7">

102+ <rdf:RDF>

103+ <cc:Work

104+ rdf:about="">

105+ <dc:format>image/svg+xml</dc:format>

106+ <dc:type

107+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

108+ <dc:title />

109+ </cc:Work>

110+ </rdf:RDF>

111+ </metadata>

112+ <g

113+ inkscape:label="Layer 1"

114+ inkscape:groupmode="layer"

115+ id="layer1">

116+ <text

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"

119+ x="268"

120+ y="495.36218"

121+ id="text4136"

122+ sodipodi:linespacing="125%"

123+ inkscape:export-xdpi="61.120499"

124+ inkscape:export-ydpi="61.120499"><tspan

125+ sodipodi:role="line"

126+ id="tspan4138"

127+ x="268"

128+ y="495.36218"

129+ style="font-size:12.5px">data TT : Type where</tspan><tspan

130+ sodipodi:role="line"

131+ x="268"

132+ y="510.98718"

133+ id="tspan4140"

134+ style="font-size:12.5px"> P : NameType -&gt; TTName -&gt; TT -&gt; TT</tspan><tspan

135+ sodipodi:role="line"

136+ x="268"

137+ y="526.61218"

138+ style="font-size:12.5px"

139+ id="tspan4142"> V : Int -&gt; TT</tspan><tspan

140+ sodipodi:role="line"

141+ x="268"

142+ y="542.23718"

143+ style="font-size:12.5px"

144+ id="tspan4144"> Bind : TTName -&gt; Binder TT -&gt; TT -&gt; TT</tspan><tspan

145+ sodipodi:role="line"

146+ x="268"

147+ y="557.86218"

148+ style="font-size:12.5px"

149+ id="tspan4146"> App : TT -&gt; TT -&gt; TT</tspan><tspan

150+ sodipodi:role="line"

151+ x="268"

152+ y="573.48718"

153+ style="font-size:12.5px"

154+ id="tspan4148"> TConst : Const -&gt; TT</tspan><tspan

155+ sodipodi:role="line"

156+ x="268"

157+ y="589.11218"

158+ style="font-size:12.5px"

159+ id="tspan4150"> Erased : TT</tspan><tspan

160+ sodipodi:role="line"

161+ x="268"

162+ y="604.73718"

163+ style="font-size:12.5px"

164+ id="tspan4152"> TType : TTUExp -&gt; TT</tspan><tspan

165+ sodipodi:role="line"

166+ x="268"

167+ y="620.36218"

168+ style="font-size:12.5px"

169+ id="tspan4154"> UType : Universe -&gt; TT</tspan></text>

170+ <text

171+ sodipodi:linespacing="125%"

172+ id="text4156"

173+ y="485.36218"

174+ x="509"

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

179+ id="tspan4174"

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"

181+ y="485.36218"

182+ x="509"

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"

185+ y="500.98718"

186+ x="509"

187+ sodipodi:role="line"

188+ id="tspan4197"> from name</tspan></text>

189+ <path

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"

192+ id="path4220"

193+ inkscape:connector-curvature="0"

194+ inkscape:export-xdpi="61.120499"

195+ inkscape:export-ydpi="61.120499"

196+ sodipodi:nodetypes="cc" />

197+ <text

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"

200+ x="392"

201+ y="526.36218"

202+ id="text4222"

203+ sodipodi:linespacing="125%"

204+ inkscape:export-xdpi="61.120499"

205+ inkscape:export-ydpi="61.120499"><tspan

206+ sodipodi:role="line"

207+ x="392"

208+ y="526.36218"

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>

211+ <path

212+ inkscape:connector-curvature="0"

213+ id="path4226"

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" />

219+ <text

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"

222+ x="537"

223+ y="533.36218"

224+ id="text4228"

225+ sodipodi:linespacing="125%"

226+ inkscape:export-xdpi="61.120499"

227+ inkscape:export-ydpi="61.120499"><tspan

228+ sodipodi:role="line"

229+ x="537"

230+ y="533.36218"

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"

234+ x="537"

235+ y="548.98718"

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>

238+ <path

239+ inkscape:connector-curvature="0"

240+ id="path4232"

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" />

246+ <text

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"

249+ x="417"

250+ y="555.36218"

251+ id="text4236"

252+ sodipodi:linespacing="125%"

253+ inkscape:export-xdpi="61.120499"

254+ inkscape:export-ydpi="61.120499"><tspan

255+ sodipodi:role="line"

256+ x="417"

257+ y="555.36218"

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>

260+ <path

261+ inkscape:connector-curvature="0"

262+ id="path4240"

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" />

268+ <text

269+ sodipodi:linespacing="125%"

270+ id="text4253"

271+ y="569.36218"

272+ x="421"

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

277+ id="tspan4255"

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"

279+ y="569.36218"

280+ x="421"

281+ sodipodi:role="line">intager, char, string, etc.</tspan></text>

282+ <path

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"

286+ id="path4257"

287+ inkscape:connector-curvature="0"

288+ inkscape:export-xdpi="61.120499"

289+ inkscape:export-ydpi="61.120499" />

290+ <text

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"

293+ x="374"

294+ y="586.36218"

295+ id="text4270"

296+ sodipodi:linespacing="125%"

297+ inkscape:export-xdpi="61.120499"

298+ inkscape:export-ydpi="61.120499"><tspan

299+ sodipodi:role="line"

300+ x="374"

301+ y="586.36218"

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>

304+ <path

305+ inkscape:connector-curvature="0"

306+ id="path4274"

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" />

312+ <text

313+ sodipodi:linespacing="125%"

314+ id="text4276"

315+ y="603.36218"

316+ x="429"

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

321+ id="tspan4278"

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"

323+ y="603.36218"

324+ x="429"

325+ sodipodi:role="line">type of types</tspan></text>

326+ <path

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"

330+ id="path4280"

331+ inkscape:connector-curvature="0"

332+ inkscape:export-xdpi="61.120499"

333+ inkscape:export-ydpi="61.120499" />

334+ <text

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"

337+ x="433"

338+ y="619.36218"

339+ id="text4293"

340+ sodipodi:linespacing="125%"

341+ inkscape:export-xdpi="61.120499"

342+ inkscape:export-ydpi="61.120499"><tspan

343+ sodipodi:role="line"

344+ x="433"

345+ y="619.36218"

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>

348+ <path

349+ inkscape:connector-curvature="0"

350+ id="path4297"

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" />

356+ <text

357+ sodipodi:linespacing="125%"

358+ id="text4397"

359+ y="463.36218"

360+ x="375"

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

365+ id="tspan4399"

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"

367+ y="463.36218"

368+ x="375"

369+ sodipodi:role="line">elements of core language</tspan></text>

370+ <rect

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"

372+ id="rect4400"

373+ width="392"

374+ height="185"

375+ x="262"

376+ y="447.36218"

377+ inkscape:export-xdpi="61.120499"

378+ inkscape:export-ydpi="61.120499" />

379+ <text

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"

382+ x="264"

383+ y="466.36218"

384+ id="text4402"

385+ sodipodi:linespacing="125%"

386+ inkscape:export-xdpi="61.120499"

387+ inkscape:export-ydpi="61.120499"><tspan

388+ sodipodi:role="line"

389+ id="tspan4404"

390+ x="264"

391+ y="466.36218"

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>

393+ <text

394+ inkscape:export-ydpi="61.120499"

395+ inkscape:export-xdpi="61.120499"

396+ sodipodi:linespacing="125%"

397+ id="text4328"

398+ y="262.36218"

399+ x="96"

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

402+ id="tspan4346"

403+ style="font-size:12.5px"

404+ y="262.36218"

405+ x="96"

406+ sodipodi:role="line">env</tspan><tspan

407+ style="font-size:12.5px"

408+ y="277.98718"

409+ x="96"

410+ sodipodi:role="line"

411+ id="tspan4454">goal</tspan><tspan

412+ style="font-size:12.5px"

413+ y="293.61218"

414+ x="96"

415+ sodipodi:role="line"

416+ id="tspan4456">holes</tspan><tspan

417+ style="font-size:12.5px"

418+ y="309.23718"

419+ x="96"

420+ sodipodi:role="line"

421+ id="tspan4458">guess</tspan></text>

422+ <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"

427+ x="163"

428+ y="262.36218"

429+ id="text4348"

430+ sodipodi:linespacing="125%"><tspan

431+ id="tspan4352"

432+ sodipodi:role="line"

433+ x="163"

434+ y="262.36218"

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"

437+ x="163"

438+ y="277.98718"

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"

442+ x="163"

443+ y="293.61218"

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"

447+ x="163"

448+ y="309.23718"

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>

451+ <path

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"

457+ id="path4360"

458+ inkscape:connector-curvature="0" />

459+ <text

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"

464+ x="64"

465+ y="286.36218"

466+ id="text4400"

467+ sodipodi:linespacing="125%"><tspan

468+ sodipodi:role="line"

469+ x="64"

470+ y="286.36218"

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>

473+ <rect

474+ inkscape:export-ydpi="61.120499"

475+ inkscape:export-xdpi="61.120499"

476+ y="219.36218"

477+ x="53"

478+ height="224"

479+ width="289"

480+ id="rect4404"

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" />

482+ <text

483+ inkscape:export-ydpi="61.120499"

484+ inkscape:export-xdpi="61.120499"

485+ sodipodi:linespacing="125%"

486+ id="text4406"

487+ y="238.36218"

488+ x="55"

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'"

492+ y="238.36218"

493+ x="55"

494+ id="tspan4408"

495+ sodipodi:role="line">Elab Monad</tspan></text>

496+ <path

497+ inkscape:connector-curvature="0"

498+ id="path4468"

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" />

504+ <path

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"

510+ id="path4470"

511+ inkscape:connector-curvature="0" />

512+ <path

513+ inkscape:connector-curvature="0"

514+ id="path4472"

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" />

520+ <path

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"

523+ id="path4476"

524+ inkscape:connector-curvature="0"

525+ sodipodi:nodetypes="cc"

526+ inkscape:export-xdpi="61.120499"

527+ inkscape:export-ydpi="61.120499" />

528+ <path

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"

531+ id="path12613"

532+ inkscape:connector-curvature="0"

533+ sodipodi:nodetypes="cc"

534+ inkscape:export-xdpi="61.120499"

535+ inkscape:export-ydpi="61.120499" />

536+ <text

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"

539+ x="147"

540+ y="373.36218"

541+ id="text15201"

542+ sodipodi:linespacing="125%"

543+ inkscape:export-xdpi="61.120499"

544+ inkscape:export-ydpi="61.120499"><tspan

545+ id="tspan15209"

546+ sodipodi:role="line"

547+ x="147"

548+ y="373.36218"

549+ style="font-size:12.5px">solve</tspan><tspan

550+ sodipodi:role="line"

551+ x="147"

552+ y="388.98718"

553+ style="font-size:12.5px"

554+ id="tspan15220">fill</tspan><tspan

555+ sodipodi:role="line"

556+ x="147"

557+ y="404.61218"

558+ style="font-size:12.5px"

559+ id="tspan15222">apply</tspan><tspan

560+ sodipodi:role="line"

561+ x="147"

562+ y="420.23718"

563+ style="font-size:12.5px"

564+ id="tspan15224">focus</tspan><tspan

565+ sodipodi:role="line"

566+ x="147"

567+ y="435.86218"

568+ style="font-size:12.5px"

569+ id="tspan15226">...</tspan></text>

570+ <text

571+ sodipodi:linespacing="125%"

572+ id="text18672"

573+ y="396.36218"

574+ x="94"

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

579+ id="tspan18674"

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"

581+ y="396.36218"

582+ x="94"

583+ sodipodi:role="line">tactics</tspan></text>

584+ </g>

585+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="elabProofState.svg">

19+ <defs

20+ id="defs4" />

21+ <sodipodi:namedview

22+ id="base"

23+ pagecolor="#ffffff"

24+ bordercolor="#666666"

25+ borderopacity="1.0"

26+ inkscape:pageopacity="0.0"

27+ inkscape:pageshadow="2"

28+ inkscape:zoom="1"

29+ inkscape:cx="252.75613"

30+ inkscape:cy="520"

31+ inkscape:document-units="px"

32+ inkscape:current-layer="layer1"

33+ showgrid="false"

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" />

39+ <metadata

40+ id="metadata7">

41+ <rdf:RDF>

42+ <cc:Work

43+ rdf:about="">

44+ <dc:format>image/svg+xml</dc:format>

45+ <dc:type

46+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

47+ <dc:title />

48+ </cc:Work>

49+ </rdf:RDF>

50+ </metadata>

51+ <g

52+ inkscape:label="Layer 1"

53+ inkscape:groupmode="layer"

54+ id="layer1">

55+ <text

56+ sodipodi:linespacing="125%"

57+ id="text4148"

58+ y="330.36218"

59+ x="219"

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"

61+ xml:space="preserve"

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'"

65+ y="330.36218"

66+ x="219"

67+ id="tspan4150"

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'"

70+ y="349.11218"

71+ x="219"

72+ sodipodi:role="line"

73+ id="tspan4206"> term</tspan></text>

74+ <text

75+ xml:space="preserve"

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+ x="240"

78+ y="303.36218"

79+ id="text4160"

80+ sodipodi:linespacing="125%"

81+ inkscape:export-xdpi="61.120499"

82+ inkscape:export-ydpi="61.120499"><tspan

83+ sodipodi:role="line"

84+ id="tspan4162"

85+ x="240"

86+ y="303.36218"

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>

88+ <text

89+ sodipodi:linespacing="125%"

90+ id="text4202"

91+ y="392.36218"

92+ x="355"

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"

94+ xml:space="preserve"

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'"

98+ y="392.36218"

99+ x="355"

100+ id="tspan4204"

101+ sodipodi:role="line">original goal</tspan></text>

102+ <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"

105+ x="213"

106+ y="377.36218"

107+ id="text4208"

108+ sodipodi:linespacing="125%"

109+ inkscape:export-xdpi="61.120499"

110+ inkscape:export-ydpi="61.120499"><tspan

111+ id="tspan4212"

112+ sodipodi:role="line"

113+ x="213"

114+ y="377.36218"

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"

117+ x="213"

118+ y="396.11218"

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"

122+ x="213"

123+ y="414.86218"

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>

126+ <text

127+ sodipodi:linespacing="125%"

128+ id="text4230"

129+ y="487.36218"

130+ x="148"

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'"

136+ y="487.36218"

137+ x="148"

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'"

141+ y="506.11218"

142+ x="148"

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'"

146+ y="524.86218"

147+ x="148"

148+ sodipodi:role="line"

149+ id="tspan4253">Also store maximum RigCount of the namel</tspan></text>

150+ <text

151+ inkscape:export-ydpi="61.120499"

152+ inkscape:export-xdpi="61.120499"

153+ sodipodi:linespacing="125%"

154+ id="text4173"

155+ y="198.36218"

156+ x="135"

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"

160+ y="198.36218"

161+ x="135"

162+ id="tspan4175"

163+ sodipodi:role="line">Environment</tspan></text>

164+ <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"

167+ x="350"

168+ y="197.36218"

169+ id="text4177"

170+ sodipodi:linespacing="125%"

171+ inkscape:export-xdpi="61.120499"

172+ inkscape:export-ydpi="61.120499"><tspan

173+ sodipodi:role="line"

174+ id="tspan4179"

175+ x="350"

176+ y="197.36218"

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>

178+ <text

179+ inkscape:export-ydpi="61.120499"

180+ inkscape:export-xdpi="61.120499"

181+ sodipodi:linespacing="125%"

182+ id="text4181"

183+ y="197.36218"

184+ x="460"

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"

188+ y="197.36218"

189+ x="460"

190+ id="tspan4183"

191+ sodipodi:role="line">Guess</tspan></text>

192+ <text

193+ inkscape:export-ydpi="61.120499"

194+ inkscape:export-xdpi="61.120499"

195+ sodipodi:linespacing="125%"

196+ id="text4185"

197+ y="199.36218"

198+ x="247"

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"

202+ y="199.36218"

203+ x="247"

204+ id="tspan4187"

205+ sodipodi:role="line">Goal</tspan></text>

206+ <rect

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"

208+ id="rect4189"

209+ width="95"

210+ height="32"

211+ x="134"

212+ y="205.3622"

213+ inkscape:export-xdpi="61.120499"

214+ inkscape:export-ydpi="61.120499" />

215+ <rect

216+ y="205.3622"

217+ x="241"

218+ height="32"

219+ width="95"

220+ id="rect4191"

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" />

224+ <rect

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"

226+ id="rect4195"

227+ width="95"

228+ height="32"

229+ x="454"

230+ y="205.3622"

231+ inkscape:export-xdpi="61.120499"

232+ inkscape:export-ydpi="61.120499" />

233+ <rect

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"

235+ id="rect4197"

236+ width="95"

237+ height="32"

238+ x="346"

239+ y="237.3622"

240+ inkscape:export-xdpi="61.120499"

241+ inkscape:export-ydpi="61.120499" />

242+ <rect

243+ y="269.36218"

244+ x="346"

245+ height="32"

246+ width="95"

247+ id="rect4199"

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" />

251+ <rect

252+ y="205.3622"

253+ x="346"

254+ height="32"

255+ width="95"

256+ id="rect4201"

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" />

260+ <path

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"

263+ id="path4206"

264+ inkscape:connector-curvature="0"

265+ inkscape:export-xdpi="61.120499"

266+ inkscape:export-ydpi="61.120499"

267+ sodipodi:nodetypes="cc" />

268+ <path

269+ inkscape:connector-curvature="0"

270+ id="path4208"

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" />

276+ <text

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"

281+ x="360"

282+ y="366.36218"

283+ id="text4210"

284+ sodipodi:linespacing="125%"><tspan

285+ sodipodi:role="line"

286+ id="tspan4213"

287+ x="360"

288+ y="366.36218"

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>

290+ <rect

291+ inkscape:export-ydpi="61.120499"

292+ inkscape:export-xdpi="61.120499"

293+ y="237.3622"

294+ x="134"

295+ height="32"

296+ width="95"

297+ id="rect4747"

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" />

299+ <rect

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"

303+ id="rect4749"

304+ width="95"

305+ height="32"

306+ x="134"

307+ y="269.36218" />

308+ <text

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"

313+ x="148"

314+ y="450.36218"

315+ id="text4751"

316+ sodipodi:linespacing="125%"><tspan

317+ id="tspan4757"

318+ sodipodi:role="line"

319+ x="148"

320+ y="450.36218"

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"

323+ x="148"

324+ y="469.11218"

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>

327+ <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"

332+ x="349.25366"

333+ y="319.99084"

334+ id="text4210-3"

335+ sodipodi:linespacing="125%"><tspan

336+ sodipodi:role="line"

337+ id="tspan4213-6"

338+ x="349.25366"

339+ y="319.99084"

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>

341+ <text

342+ sodipodi:linespacing="125%"

343+ id="text4782"

344+ y="251.99084"

345+ x="495.25366"

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'"

351+ y="251.99084"

352+ x="495.25366"

353+ id="tspan4784"

354+ sodipodi:role="line">TT</tspan></text>

355+ </g>

356+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="elabProofStateEx1_1.svg">

19+ <defs

20+ id="defs4" />

21+ <sodipodi:namedview

22+ id="base"

23+ pagecolor="#ffffff"

24+ bordercolor="#666666"

25+ borderopacity="1.0"

26+ inkscape:pageopacity="0.0"

27+ inkscape:pageshadow="2"

28+ inkscape:zoom="1"

29+ inkscape:cx="298"

30+ inkscape:cy="772.5"

31+ inkscape:document-units="px"

32+ inkscape:current-layer="layer1"

33+ showgrid="false"

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" />

39+ <metadata

40+ id="metadata7">

41+ <rdf:RDF>

42+ <cc:Work

43+ rdf:about="">

44+ <dc:format>image/svg+xml</dc:format>

45+ <dc:type

46+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

47+ <dc:title />

48+ </cc:Work>

49+ </rdf:RDF>

50+ </metadata>

51+ <g

52+ inkscape:label="Layer 1"

53+ inkscape:groupmode="layer"

54+ id="layer1">

55+ <text

56+ sodipodi:linespacing="125%"

57+ id="text4140"

58+ y="226.36218"

59+ x="401"

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"

61+ xml:space="preserve"

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'"

65+ y="226.36218"

66+ x="401"

67+ sodipodi:role="line"

68+ id="tspan4144">hole_2</tspan></text>

69+ <text

70+ inkscape:export-ydpi="61.120499"

71+ inkscape:export-xdpi="61.120499"

72+ sodipodi:linespacing="125%"

73+ id="text4173"

74+ y="198.36218"

75+ x="135"

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"

79+ y="198.36218"

80+ x="135"

81+ id="tspan4175"

82+ sodipodi:role="line">Environment</tspan></text>

83+ <text

84+ xml:space="preserve"

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"

86+ x="393"

87+ y="197.36218"

88+ id="text4177"

89+ sodipodi:linespacing="125%"

90+ inkscape:export-xdpi="61.120499"

91+ inkscape:export-ydpi="61.120499"><tspan

92+ sodipodi:role="line"

93+ id="tspan4179"

94+ x="393"

95+ y="197.36218"

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>

97+ <text

98+ inkscape:export-ydpi="61.120499"

99+ inkscape:export-xdpi="61.120499"

100+ sodipodi:linespacing="125%"

101+ id="text4181"

102+ y="197.36218"

103+ x="503"

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"

107+ y="197.36218"

108+ x="503"

109+ id="tspan4183"

110+ sodipodi:role="line">Guess</tspan></text>

111+ <text

112+ inkscape:export-ydpi="61.120499"

113+ inkscape:export-xdpi="61.120499"

114+ sodipodi:linespacing="125%"

115+ id="text4185"

116+ y="199.36218"

117+ x="247"

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"

121+ y="199.36218"

122+ x="247"

123+ id="tspan4187"

124+ sodipodi:role="line">Goal</tspan></text>

125+ <rect

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"

127+ id="rect4189"

128+ width="39"

129+ height="32"

130+ x="134"

131+ y="205.3622"

132+ inkscape:export-xdpi="61.120499"

133+ inkscape:export-ydpi="61.120499" />

134+ <rect

135+ y="206.3622"

136+ x="182"

137+ height="32"

138+ width="200"

139+ id="rect4191"

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" />

143+ <rect

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"

145+ id="rect4195"

146+ width="95"

147+ height="32"

148+ x="494"

149+ y="206.3622"

150+ inkscape:export-xdpi="61.120499"

151+ inkscape:export-ydpi="61.120499" />

152+ <rect

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"

154+ id="rect4197"

155+ width="95"

156+ height="32"

157+ x="389"

158+ y="237.3622"

159+ inkscape:export-xdpi="61.120499"

160+ inkscape:export-ydpi="61.120499" />

161+ <rect

162+ y="269.36218"

163+ x="389"

164+ height="32"

165+ width="95"

166+ id="rect4199"

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" />

170+ <rect

171+ y="205.3622"

172+ x="389"

173+ height="32"

174+ width="95"

175+ id="rect4201"

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" />

179+ <text

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"

184+ x="400"

185+ y="257.36218"

186+ id="text4276"

187+ sodipodi:linespacing="125%"><tspan

188+ id="tspan4280"

189+ sodipodi:role="line"

190+ x="400"

191+ y="257.36218"

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>

193+ <text

194+ sodipodi:linespacing="125%"

195+ id="text4159"

196+ y="225.36218"

197+ x="141"

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'"

203+ y="225.36218"

204+ x="141"

205+ sodipodi:role="line"

206+ id="tspan4161">[ ]</tspan></text>

207+ <text

208+ sodipodi:linespacing="125%"

209+ id="text4163"

210+ y="275.36218"

211+ x="135"

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'"

217+ y="275.36218"

218+ x="135"

219+ sodipodi:role="line"

220+ id="tspan4165">starts off empty</tspan></text>

221+ <path

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"

224+ id="path4167"

225+ inkscape:connector-curvature="0"

226+ inkscape:export-xdpi="61.120499"

227+ inkscape:export-ydpi="61.120499"

228+ sodipodi:nodetypes="cc" />

229+ <text

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"

234+ x="188"

235+ y="227.36218"

236+ id="text4786"

237+ sodipodi:linespacing="125%"><tspan

238+ sodipodi:role="line"

239+ x="188"

240+ y="227.36218"

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-&gt;Nat)</tspan></text>

243+ <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"

248+ x="233.57927"

249+ y="309.21585"

250+ id="text4794"

251+ sodipodi:linespacing="125%"><tspan

252+ id="tspan4796"

253+ sodipodi:role="line"

254+ x="233.57927"

255+ y="309.21585"

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"

258+ x="233.57927"

259+ y="327.96585"

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>

262+ <path

263+ inkscape:connector-curvature="0"

264+ id="path4798"

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" />

270+ <text

271+ sodipodi:linespacing="125%"

272+ id="text4800"

273+ y="335.85608"

274+ x="383.54877"

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'"

280+ y="335.85608"

281+ x="383.54877"

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'"

285+ y="354.60608"

286+ x="383.54877"

287+ sodipodi:role="line"

288+ id="tspan4812">names for the holes</tspan></text>

289+ <path

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"

293+ id="path4804"

294+ inkscape:connector-curvature="0"

295+ inkscape:export-xdpi="61.120499"

296+ inkscape:export-ydpi="61.120499" />

297+ <text

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"

302+ x="498"

303+ y="227.36218"

304+ id="text4806"

305+ sodipodi:linespacing="125%"><tspan

306+ id="tspan4808"

307+ sodipodi:role="line"

308+ x="498"

309+ y="227.36218"

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>

311+ </g>

312+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

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">

22+ <defs

23+ id="defs4">

24+ <marker

25+ inkscape:stockid="Arrow1Mend"

26+ orient="auto"

27+ refY="0.0"

28+ refX="0.0"

29+ id="Arrow1Mend"

30+ style="overflow:visible;"

31+ inkscape:isstock="true">

32+ <path

33+ id="path4252"

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)" />

37+ </marker>

38+ </defs>

39+ <sodipodi:namedview

40+ id="base"

41+ pagecolor="#ffffff"

42+ bordercolor="#666666"

43+ borderopacity="1.0"

44+ inkscape:pageopacity="0.0"

45+ inkscape:pageshadow="2"

46+ inkscape:zoom="1"

47+ inkscape:cx="211.75967"

48+ inkscape:cy="688.76752"

49+ inkscape:document-units="px"

50+ inkscape:current-layer="layer1"

51+ showgrid="false"

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" />

57+ <metadata

58+ id="metadata7">

59+ <rdf:RDF>

60+ <cc:Work

61+ rdf:about="">

62+ <dc:format>image/svg+xml</dc:format>

63+ <dc:type

64+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

65+ <dc:title />

66+ </cc:Work>

67+ </rdf:RDF>

68+ </metadata>

69+ <g

70+ inkscape:label="Layer 1"

71+ inkscape:groupmode="layer"

72+ id="layer1">

73+ <text

74+ sodipodi:linespacing="125%"

75+ id="text4140"

76+ y="226.36218"

77+ x="401"

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"

79+ xml:space="preserve"

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'"

83+ y="226.36218"

84+ x="401"

85+ sodipodi:role="line"

86+ id="tspan4144">hole_2</tspan></text>

87+ <text

88+ inkscape:export-ydpi="61.120499"

89+ inkscape:export-xdpi="61.120499"

90+ sodipodi:linespacing="125%"

91+ id="text4173"

92+ y="198.36218"

93+ x="135"

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"

97+ y="198.36218"

98+ x="135"

99+ id="tspan4175"

100+ sodipodi:role="line">Environment</tspan></text>

101+ <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"

104+ x="393"

105+ y="197.36218"

106+ id="text4177"

107+ sodipodi:linespacing="125%"

108+ inkscape:export-xdpi="61.120499"

109+ inkscape:export-ydpi="61.120499"><tspan

110+ sodipodi:role="line"

111+ id="tspan4179"

112+ x="393"

113+ y="197.36218"

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>

115+ <text

116+ inkscape:export-ydpi="61.120499"

117+ inkscape:export-xdpi="61.120499"

118+ sodipodi:linespacing="125%"

119+ id="text4181"

120+ y="197.36218"

121+ x="503"

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"

125+ y="197.36218"

126+ x="503"

127+ id="tspan4183"

128+ sodipodi:role="line">Guess</tspan></text>

129+ <text

130+ inkscape:export-ydpi="61.120499"

131+ inkscape:export-xdpi="61.120499"

132+ sodipodi:linespacing="125%"

133+ id="text4185"

134+ y="199.36218"

135+ x="247"

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"

139+ y="199.36218"

140+ x="247"

141+ id="tspan4187"

142+ sodipodi:role="line">Goal</tspan></text>

143+ <rect

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"

145+ id="rect4189"

146+ width="92"

147+ height="32"

148+ x="134"

149+ y="205.3622"

150+ inkscape:export-xdpi="61.120499"

151+ inkscape:export-ydpi="61.120499" />

152+ <rect

153+ y="206.3622"

154+ x="234"

155+ height="32"

156+ width="148"

157+ id="rect4191"

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" />

161+ <rect

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"

163+ id="rect4195"

164+ width="95"

165+ height="32"

166+ x="497"

167+ y="205.3622"

168+ inkscape:export-xdpi="61.120499"

169+ inkscape:export-ydpi="61.120499" />

170+ <rect

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"

172+ id="rect4197"

173+ width="95"

174+ height="32"

175+ x="389"

176+ y="237.3622"

177+ inkscape:export-xdpi="61.120499"

178+ inkscape:export-ydpi="61.120499" />

179+ <rect

180+ y="269.36218"

181+ x="389"

182+ height="32"

183+ width="95"

184+ id="rect4199"

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" />

188+ <rect

189+ y="205.3622"

190+ x="389"

191+ height="32"

192+ width="95"

193+ id="rect4201"

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" />

197+ <text

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"

202+ x="400"

203+ y="257.36218"

204+ id="text4276"

205+ sodipodi:linespacing="125%"><tspan

206+ id="tspan4280"

207+ sodipodi:role="line"

208+ x="400"

209+ y="257.36218"

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>

211+ <text

212+ sodipodi:linespacing="125%"

213+ id="text4159"

214+ y="225.36218"

215+ x="140"

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'"

221+ y="225.36218"

222+ x="140"

223+ sodipodi:role="line"

224+ id="tspan4161">(x, λ Nat)</tspan></text>

225+ <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"

230+ x="266"

231+ y="226.36218"

232+ id="text4786"

233+ sodipodi:linespacing="125%"><tspan

234+ sodipodi:role="line"

235+ x="266"

236+ y="226.36218"

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>

239+ <text

240+ sodipodi:linespacing="125%"

241+ id="text4800"

242+ y="290.36218"

243+ x="163"

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'"

249+ y="290.36218"

250+ x="163"

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'"

254+ y="309.11218"

255+ x="163"

256+ sodipodi:role="line"

257+ id="tspan6225">with a lambda</tspan></text>

258+ <path

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"

262+ id="path4804"

263+ inkscape:connector-curvature="0"

264+ inkscape:export-xdpi="61.120499"

265+ inkscape:export-ydpi="61.120499" />

266+ <text

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"

271+ x="510"

272+ y="226.36218"

273+ id="text4174"

274+ sodipodi:linespacing="125%"><tspan

275+ id="tspan4176"

276+ sodipodi:role="line"

277+ x="510"

278+ y="226.36218"

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>

280+ </g>

281+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

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">

22+ <defs

23+ id="defs4" />

24+ <sodipodi:namedview

25+ id="base"

26+ pagecolor="#ffffff"

27+ bordercolor="#666666"

28+ borderopacity="1.0"

29+ inkscape:pageopacity="0.0"

30+ inkscape:pageshadow="2"

31+ inkscape:zoom="1"

32+ inkscape:cx="345.95856"

33+ inkscape:cy="688.76752"

34+ inkscape:document-units="px"

35+ inkscape:current-layer="layer1"

36+ showgrid="false"

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" />

42+ <metadata

43+ id="metadata7">

44+ <rdf:RDF>

45+ <cc:Work

46+ rdf:about="">

47+ <dc:format>image/svg+xml</dc:format>

48+ <dc:type

49+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

50+ <dc:title />

51+ </cc:Work>

52+ </rdf:RDF>

53+ </metadata>

54+ <g

55+ inkscape:label="Layer 1"

56+ inkscape:groupmode="layer"

57+ id="layer1">

58+ <text

59+ sodipodi:linespacing="125%"

60+ id="text4140"

61+ y="226.36218"

62+ x="401"

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"

64+ xml:space="preserve"

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'"

69+ y="226.36218"

70+ x="401"

71+ sodipodi:role="line"

72+ id="tspan4144">hole_2</tspan></text>

73+ <text

74+ inkscape:export-ydpi="61.120499"

75+ inkscape:export-xdpi="61.120499"

76+ sodipodi:linespacing="125%"

77+ id="text4173"

78+ y="198.36218"

79+ x="135"

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"

81+ xml:space="preserve"

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"

84+ y="198.36218"

85+ x="135"

86+ id="tspan4175"

87+ sodipodi:role="line">Environment</tspan></text>

88+ <text

89+ xml:space="preserve"

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"

91+ x="393"

92+ y="197.36218"

93+ id="text4177"

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

98+ sodipodi:role="line"

99+ id="tspan4179"

100+ x="393"

101+ y="197.36218"

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>

103+ <text

104+ inkscape:export-ydpi="61.120499"

105+ inkscape:export-xdpi="61.120499"

106+ sodipodi:linespacing="125%"

107+ id="text4181"

108+ y="197.36218"

109+ x="503"

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"

114+ y="197.36218"

115+ x="503"

116+ id="tspan4183"

117+ sodipodi:role="line">Guess</tspan></text>

118+ <text

119+ inkscape:export-ydpi="61.120499"

120+ inkscape:export-xdpi="61.120499"

121+ sodipodi:linespacing="125%"

122+ id="text4185"

123+ y="199.36218"

124+ x="247"

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"

129+ y="199.36218"

130+ x="247"

131+ id="tspan4187"

132+ sodipodi:role="line">Goal</tspan></text>

133+ <rect

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"

135+ id="rect4189"

136+ width="92"

137+ height="32"

138+ x="134"

139+ y="205.3622"

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" />

143+ <rect

144+ y="206.3622"

145+ x="234"

146+ height="32"

147+ width="148"

148+ id="rect4191"

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" />

153+ <rect

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"

155+ id="rect4195"

156+ width="95"

157+ height="32"

158+ x="497"

159+ y="205.3622"

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" />

163+ <rect

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"

165+ id="rect4197"

166+ width="95"

167+ height="32"

168+ x="389"

169+ y="237.3622"

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" />

173+ <rect

174+ y="205.3622"

175+ x="389"

176+ height="32"

177+ width="95"

178+ id="rect4201"

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" />

183+ <text

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"

188+ x="400"

189+ y="257.36218"

190+ id="text4276"

191+ sodipodi:linespacing="125%"

192+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan

193+ id="tspan4280"

194+ sodipodi:role="line"

195+ x="400"

196+ y="257.36218"

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>

198+ <text

199+ sodipodi:linespacing="125%"

200+ id="text4159"

201+ y="225.36218"

202+ x="140"

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'"

209+ y="225.36218"

210+ x="140"

211+ sodipodi:role="line"

212+ id="tspan4161">(x, λ Nat)</tspan></text>

213+ <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"

218+ x="266"

219+ y="226.36218"

220+ id="text4786"

221+ sodipodi:linespacing="125%"

222+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan

223+ sodipodi:role="line"

224+ x="266"

225+ y="226.36218"

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>

228+ <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"

233+ x="510"

234+ y="226.36218"

235+ id="text4174"

236+ sodipodi:linespacing="125%"

237+ inkscape:export-filename="/home/master/euclid/prog/idris/elaborator/elabTactics/example1/elabProofStateEx1_3.png"><tspan

238+ id="tspan4176"

239+ sodipodi:role="line"

240+ x="510"

241+ y="226.36218"

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>

243+ </g>

244+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 210 297"

15+ version="1.1"

16+ id="svg8"

17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"

18+ sodipodi:docname="fill.svg">

19+ <defs

20+ id="defs2">

21+ <marker

22+ inkscape:isstock="true"

23+ style="overflow:visible;"

24+ id="marker838"

25+ refX="0.0"

26+ refY="0.0"

27+ orient="auto"

28+ inkscape:stockid="Arrow1Mend">

29+ <path

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 "

33+ id="path836" />

34+ </marker>

35+ <marker

36+ inkscape:stockid="Arrow1Mend"

37+ orient="auto"

38+ refY="0.0"

39+ refX="0.0"

40+ id="Arrow1Mend"

41+ style="overflow:visible;"

42+ inkscape:isstock="true"

43+ inkscape:collect="always">

44+ <path

45+ id="path4529"

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)" />

49+ </marker>

50+ </defs>

51+ <sodipodi:namedview

52+ id="base"

53+ pagecolor="#ffffff"

54+ bordercolor="#666666"

55+ borderopacity="1.0"

56+ inkscape:pageopacity="0.0"

57+ inkscape:pageshadow="2"

58+ inkscape:zoom="1"

59+ inkscape:cx="313.5"

60+ inkscape:cy="696.5"

61+ inkscape:document-units="mm"

62+ inkscape:current-layer="layer1"

63+ showgrid="false"

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" />

69+ <metadata

70+ id="metadata5">

71+ <rdf:RDF>

72+ <cc:Work

73+ rdf:about="">

74+ <dc:format>image/svg+xml</dc:format>

75+ <dc:type

76+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

77+ <dc:title />

78+ </cc:Work>

79+ </rdf:RDF>

80+ </metadata>

81+ <g

82+ inkscape:label="Layer 1"

83+ inkscape:groupmode="layer"

84+ id="layer1">

85+ <rect

86+ style="fill:#ffff00;fill-opacity:1;stroke-width:0.26458332"

87+ id="rect22"

88+ width="31.75"

89+ height="5.5562501"

90+ x="70.114571"

91+ y="114.96667"

92+ inkscape:export-xdpi="61.120499"

93+ inkscape:export-ydpi="61.120499" />

94+ <text

95+ xml:space="preserve"

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"

97+ x="65.352081"

98+ y="105.17709"

99+ id="text12"

100+ inkscape:export-xdpi="61.120499"

101+ inkscape:export-ydpi="61.120499"><tspan

102+ sodipodi:role="line"

103+ id="tspan10"

104+ x="65.352081"

105+ y="105.17709"

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>

107+ <text

108+ id="text16"

109+ y="118.67083"

110+ x="56.356247"

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"

116+ y="118.67083"

117+ x="56.356247"

118+ id="tspan14"

119+ sodipodi:role="line">?{hole} ≈ Prelude.Nat.Z . {hole}</tspan></text>

120+ <text

121+ id="text20"

122+ y="110.99791"

123+ x="82.814583"

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"

129+ y="110.99791"

130+ x="82.814583"

131+ id="tspan18"

132+ sodipodi:role="line">fill `(Z)</tspan></text>

133+ <path

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"

136+ id="path4518"

137+ inkscape:connector-curvature="0"

138+ sodipodi:nodetypes="cc"

139+ inkscape:export-xdpi="61.120499"

140+ inkscape:export-ydpi="61.120499" />

141+ <text

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"

146+ x="63.499996"

147+ y="93.006248"

148+ id="text832"><tspan

149+ sodipodi:role="line"

150+ id="tspan830"

151+ x="63.499996"

152+ y="93.006248"

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>

154+ <path

155+ inkscape:export-ydpi="61.120499"

156+ inkscape:export-xdpi="61.120499"

157+ sodipodi:nodetypes="cc"

158+ inkscape:connector-curvature="0"

159+ id="path834"

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)" />

162+ </g>

163+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="generateDatatype.svg">

19+ <defs

20+ id="defs4">

21+ <marker

22+ inkscape:isstock="true"

23+ style="overflow:visible;"

24+ id="marker7147"

25+ refX="0.0"

26+ refY="0.0"

27+ orient="auto"

28+ inkscape:stockid="Arrow2Mend">

29+ <path

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"

33+ id="path7149" />

34+ </marker>

35+ <marker

36+ inkscape:stockid="Arrow2Mend"

37+ orient="auto"

38+ refY="0.0"

39+ refX="0.0"

40+ id="marker6819"

41+ style="overflow:visible;"

42+ inkscape:isstock="true">

43+ <path

44+ id="path6821"

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)" />

48+ </marker>

49+ <marker

50+ inkscape:isstock="true"

51+ style="overflow:visible;"

52+ id="marker6325"

53+ refX="0.0"

54+ refY="0.0"

55+ orient="auto"

56+ inkscape:stockid="Arrow2Mend">

57+ <path

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"

61+ id="path6327" />

62+ </marker>

63+ <marker

64+ inkscape:stockid="Arrow2Mend"

65+ orient="auto"

66+ refY="0.0"

67+ refX="0.0"

68+ id="marker5163"

69+ style="overflow:visible;"

70+ inkscape:isstock="true">

71+ <path

72+ id="path5165"

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)" />

76+ </marker>

77+ <marker

78+ inkscape:isstock="true"

79+ style="overflow:visible;"

80+ id="marker5133"

81+ refX="0.0"

82+ refY="0.0"

83+ orient="auto"

84+ inkscape:stockid="Arrow2Mend"

85+ inkscape:collect="always">

86+ <path

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"

90+ id="path5135" />

91+ </marker>

92+ <marker

93+ inkscape:stockid="Arrow2Mend"

94+ orient="auto"

95+ refY="0.0"

96+ refX="0.0"

97+ id="Arrow2Mend"

98+ style="overflow:visible;"

99+ inkscape:isstock="true"

100+ inkscape:collect="always">

101+ <path

102+ id="path4183"

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)" />

106+ </marker>

107+ </defs>

108+ <sodipodi:namedview

109+ id="base"

110+ pagecolor="#ffffff"

111+ bordercolor="#666666"

112+ borderopacity="1.0"

113+ inkscape:pageopacity="0.0"

114+ inkscape:pageshadow="2"

115+ inkscape:zoom="1"

116+ inkscape:cx="380.92935"

117+ inkscape:cy="520"

118+ inkscape:document-units="px"

119+ inkscape:current-layer="layer1"

120+ showgrid="false"

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" />

126+ <metadata

127+ id="metadata7">

128+ <rdf:RDF>

129+ <cc:Work

130+ rdf:about="">

131+ <dc:format>image/svg+xml</dc:format>

132+ <dc:type

133+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

134+ <dc:title></dc:title>

135+ </cc:Work>

136+ </rdf:RDF>

137+ </metadata>

138+ <g

139+ inkscape:label="Layer 1"

140+ inkscape:groupmode="layer"

141+ id="layer1">

142+ <rect

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"

144+ id="rect4136"

145+ width="201"

146+ height="69"

147+ x="116"

148+ y="203.3622"

149+ inkscape:export-xdpi="61.120499"

150+ inkscape:export-ydpi="61.120499" />

151+ <rect

152+ y="322.36218"

153+ x="113"

154+ height="69"

155+ width="201"

156+ id="rect4138"

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" />

160+ <rect

161+ y="202.3622"

162+ x="381"

163+ height="69"

164+ width="201"

165+ id="rect4140"

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" />

169+ <text

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"

172+ x="125"

173+ y="227.3622"

174+ id="text4142"

175+ sodipodi:linespacing="125%"

176+ inkscape:export-xdpi="61.120499"

177+ inkscape:export-ydpi="61.120499"><tspan

178+ sodipodi:role="line"

179+ id="tspan4144"

180+ x="125"

181+ y="227.3622">declareDatatype</tspan></text>

182+ <text

183+ sodipodi:linespacing="125%"

184+ id="text4146"

185+ y="225.3622"

186+ x="389"

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

191+ y="225.3622"

192+ x="389"

193+ id="tspan4148"

194+ sodipodi:role="line">defineDatatype</tspan></text>

195+ <path

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"

198+ id="path4150"

199+ inkscape:connector-curvature="0"

200+ inkscape:export-xdpi="61.120499"

201+ inkscape:export-ydpi="61.120499" />

202+ <text

203+ sodipodi:linespacing="125%"

204+ id="text5074"

205+ y="295.36218"

206+ x="201"

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

211+ y="295.36218"

212+ x="201"

213+ sodipodi:role="line"

214+ id="tspan5080"

215+ style="font-size:15px;fill:#ff0000">Declare</tspan></text>

216+ <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"

219+ x="117"

220+ y="344.36218"

221+ id="text5082"

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"

227+ id="tspan5084"

228+ x="117"

229+ y="344.36218">name:TTName</tspan><tspan

230+ style="font-size:15px;fill:#0000ff"

231+ id="tspan5086"

232+ sodipodi:role="line"

233+ x="117"

234+ y="363.11218">arguments:List FunArg</tspan><tspan

235+ style="font-size:15px;fill:#0000ff"

236+ id="tspan5088"

237+ sodipodi:role="line"

238+ x="117"

239+ y="381.86218">returnType:Raw</tspan></text>

240+ <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;"

243+ x="111"

244+ y="313.36218"

245+ id="text5095"

246+ sodipodi:linespacing="125%"

247+ inkscape:export-xdpi="61.120499"

248+ inkscape:export-ydpi="61.120499"><tspan

249+ style="font-size:15px;fill:#0000ff;"

250+ id="tspan5097"

251+ sodipodi:role="line"

252+ x="111"

253+ y="313.36218">TyDecl</tspan></text>

254+ <rect

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"

256+ id="rect5099"

257+ width="125"

258+ height="88"

259+ x="170"

260+ y="415.36218"

261+ inkscape:export-xdpi="61.120499"

262+ inkscape:export-ydpi="61.120499" />

263+ <path

264+ inkscape:connector-curvature="0"

265+ id="path5101"

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" />

270+ <text

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"

273+ x="260"

274+ y="408.36218"

275+ id="text5103"

276+ sodipodi:linespacing="125%"

277+ inkscape:export-xdpi="61.120499"

278+ inkscape:export-ydpi="61.120499"><tspan

279+ style="font-size:15px;fill:#ff0000"

280+ id="tspan5105"

281+ sodipodi:role="line"

282+ x="260"

283+ y="408.36218">MkFunArg</tspan></text>

284+ <text

285+ sodipodi:linespacing="125%"

286+ id="text5107"

287+ y="437.36218"

288+ x="174"

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

293+ y="437.36218"

294+ x="174"

295+ id="tspan5109"

296+ sodipodi:role="line"

297+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan

298+ y="456.11218"

299+ x="174"

300+ sodipodi:role="line"

301+ id="tspan5113"

302+ style="font-size:15px;fill:#0000ff">type:Raw</tspan><tspan

303+ y="474.86218"

304+ x="174"

305+ sodipodi:role="line"

306+ style="font-size:15px;fill:#0000ff"

307+ id="tspan5121">plicity:Plicity</tspan><tspan

308+ y="493.61218"

309+ x="174"

310+ sodipodi:role="line"

311+ style="font-size:15px;fill:#0000ff"

312+ id="tspan5123">erasure:Erasure</tspan></text>

313+ <text

314+ sodipodi:linespacing="125%"

315+ id="text5115"

316+ y="409.36218"

317+ x="170"

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

322+ y="409.36218"

323+ x="170"

324+ sodipodi:role="line"

325+ id="tspan5117"

326+ style="font-size:15px;fill:#0000ff">FunArg</tspan></text>

327+ <text

328+ sodipodi:linespacing="125%"

329+ id="text5125"

330+ y="526.36218"

331+ x="105"

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

336+ y="526.36218"

337+ x="105"

338+ sodipodi:role="line"

339+ id="tspan5127"

340+ style="font-size:15px;fill:#ff0000">Explicit</tspan><tspan

341+ y="545.11218"

342+ x="105"

343+ sodipodi:role="line"

344+ style="font-size:15px;fill:#ff0000"

345+ id="tspan5129">Implicit</tspan><tspan

346+ y="563.86218"

347+ x="105"

348+ sodipodi:role="line"

349+ style="font-size:15px;fill:#ff0000"

350+ id="tspan5131">Constraint</tspan></text>

351+ <path

352+ inkscape:connector-curvature="0"

353+ id="path5161"

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" />

359+ <path

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"

362+ id="path6319"

363+ inkscape:connector-curvature="0"

364+ sodipodi:nodetypes="cc"

365+ inkscape:export-xdpi="61.120499"

366+ inkscape:export-ydpi="61.120499" />

367+ <text

368+ sodipodi:linespacing="125%"

369+ id="text6321"

370+ y="544.36218"

371+ x="221"

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

376+ y="544.36218"

377+ x="221"

378+ sodipodi:role="line"

379+ id="tspan6323"

380+ style="font-size:15px;fill:#ff0000">Erased</tspan><tspan

381+ y="563.11218"

382+ x="221"

383+ sodipodi:role="line"

384+ style="font-size:15px;fill:#ff0000"

385+ id="tspan6773">NotErased</tspan></text>

386+ <rect

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"

388+ id="rect6775"

389+ width="247"

390+ height="49"

391+ x="347"

392+ y="322.36218"

393+ inkscape:export-xdpi="61.120499"

394+ inkscape:export-ydpi="61.120499" />

395+ <path

396+ inkscape:connector-curvature="0"

397+ id="path6777"

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" />

402+ <text

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"

405+ x="469"

406+ y="295.36218"

407+ id="text6779"

408+ sodipodi:linespacing="125%"

409+ inkscape:export-xdpi="61.120499"

410+ inkscape:export-ydpi="61.120499"><tspan

411+ style="font-size:15px;fill:#ff0000"

412+ id="tspan6781"

413+ sodipodi:role="line"

414+ x="469"

415+ y="295.36218">DefineDatatype</tspan></text>

416+ <text

417+ sodipodi:linespacing="125%"

418+ id="text6783"

419+ y="344.36218"

420+ x="351"

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

425+ y="344.36218"

426+ x="351"

427+ sodipodi:role="line"

428+ id="tspan6789"

429+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan

430+ y="363.11218"

431+ x="351"

432+ sodipodi:role="line"

433+ style="font-size:15px;fill:#0000ff"

434+ id="tspan7130">constructors : List ConstructorDefn</tspan></text>

435+ <text

436+ sodipodi:linespacing="125%"

437+ id="text6791"

438+ y="313.36218"

439+ x="379"

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

444+ y="313.36218"

445+ x="379"

446+ sodipodi:role="line"

447+ id="tspan6793"

448+ style="font-size:15px;fill:#0000ff">DataDefn</tspan></text>

449+ <rect

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"

451+ id="rect6799"

452+ width="201"

453+ height="69"

454+ x="380"

455+ y="418.36218"

456+ inkscape:export-xdpi="61.120499"

457+ inkscape:export-ydpi="61.120499" />

458+ <path

459+ inkscape:connector-curvature="0"

460+ id="path6801"

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" />

465+ <text

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"

468+ x="450"

469+ y="386.36218"

470+ id="text6803"

471+ sodipodi:linespacing="125%"

472+ inkscape:export-xdpi="61.120499"

473+ inkscape:export-ydpi="61.120499"><tspan

474+ style="font-size:15px;fill:#ff0000"

475+ id="tspan6805"

476+ sodipodi:role="line"

477+ x="450"

478+ y="386.36218">Constructor</tspan></text>

479+ <text

480+ sodipodi:linespacing="125%"

481+ id="text6807"

482+ y="440.36218"

483+ x="384"

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

488+ y="440.36218"

489+ x="384"

490+ id="tspan6809"

491+ sodipodi:role="line"

492+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan

493+ y="459.11218"

494+ x="384"

495+ sodipodi:role="line"

496+ id="tspan6811"

497+ style="font-size:15px;fill:#0000ff">arguments:List FunArg</tspan><tspan

498+ y="477.86218"

499+ x="384"

500+ sodipodi:role="line"

501+ id="tspan6813"

502+ style="font-size:15px;fill:#0000ff">returnType:Raw</tspan></text>

503+ <text

504+ sodipodi:linespacing="125%"

505+ id="text6815"

506+ y="409.36218"

507+ x="378"

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

512+ y="409.36218"

513+ x="378"

514+ sodipodi:role="line"

515+ id="tspan6817"

516+ style="font-size:15px;fill:#0000ff">ConstructorDefn</tspan></text>

517+ <text

518+ inkscape:export-ydpi="61.120499"

519+ inkscape:export-xdpi="61.120499"

520+ sodipodi:linespacing="125%"

521+ id="text7135"

522+ y="425.36218"

523+ x="307"

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

526+ y="425.36218"

527+ x="307"

528+ sodipodi:role="line"

529+ id="tspan7137"

530+ style="font-size:15px;fill:#ff0000">MkFunArg</tspan></text>

531+ <path

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"

536+ id="path7145"

537+ inkscape:connector-curvature="0"

538+ sodipodi:nodetypes="cc" />

539+ </g>

540+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="generateFunction.svg">

19+ <defs

20+ id="defs4">

21+ <marker

22+ inkscape:isstock="true"

23+ style="overflow:visible;"

24+ id="marker4348"

25+ refX="0.0"

26+ refY="0.0"

27+ orient="auto"

28+ inkscape:stockid="Arrow2Mend">

29+ <path

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"

33+ id="path4350" />

34+ </marker>

35+ <marker

36+ inkscape:isstock="true"

37+ style="overflow:visible;"

38+ id="marker7147"

39+ refX="0.0"

40+ refY="0.0"

41+ orient="auto"

42+ inkscape:stockid="Arrow2Mend">

43+ <path

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"

47+ id="path7149" />

48+ </marker>

49+ <marker

50+ inkscape:stockid="Arrow2Mend"

51+ orient="auto"

52+ refY="0.0"

53+ refX="0.0"

54+ id="marker6819"

55+ style="overflow:visible;"

56+ inkscape:isstock="true"

57+ inkscape:collect="always">

58+ <path

59+ id="path6821"

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)" />

63+ </marker>

64+ <marker

65+ inkscape:isstock="true"

66+ style="overflow:visible;"

67+ id="marker6325"

68+ refX="0.0"

69+ refY="0.0"

70+ orient="auto"

71+ inkscape:stockid="Arrow2Mend">

72+ <path

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"

76+ id="path6327" />

77+ </marker>

78+ <marker

79+ inkscape:stockid="Arrow2Mend"

80+ orient="auto"

81+ refY="0.0"

82+ refX="0.0"

83+ id="marker5163"

84+ style="overflow:visible;"

85+ inkscape:isstock="true">

86+ <path

87+ id="path5165"

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)" />

91+ </marker>

92+ <marker

93+ inkscape:isstock="true"

94+ style="overflow:visible;"

95+ id="marker5133"

96+ refX="0.0"

97+ refY="0.0"

98+ orient="auto"

99+ inkscape:stockid="Arrow2Mend"

100+ inkscape:collect="always">

101+ <path

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"

105+ id="path5135" />

106+ </marker>

107+ <marker

108+ inkscape:stockid="Arrow2Mend"

109+ orient="auto"

110+ refY="0.0"

111+ refX="0.0"

112+ id="Arrow2Mend"

113+ style="overflow:visible;"

114+ inkscape:isstock="true"

115+ inkscape:collect="always">

116+ <path

117+ id="path4183"

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)" />

121+ </marker>

122+ </defs>

123+ <sodipodi:namedview

124+ id="base"

125+ pagecolor="#ffffff"

126+ bordercolor="#666666"

127+ borderopacity="1.0"

128+ inkscape:pageopacity="0.0"

129+ inkscape:pageshadow="2"

130+ inkscape:zoom="1"

131+ inkscape:cx="380.92935"

132+ inkscape:cy="520"

133+ inkscape:document-units="px"

134+ inkscape:current-layer="layer1"

135+ showgrid="false"

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" />

141+ <metadata

142+ id="metadata7">

143+ <rdf:RDF>

144+ <cc:Work

145+ rdf:about="">

146+ <dc:format>image/svg+xml</dc:format>

147+ <dc:type

148+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

149+ <dc:title />

150+ </cc:Work>

151+ </rdf:RDF>

152+ </metadata>

153+ <g

154+ inkscape:label="Layer 1"

155+ inkscape:groupmode="layer"

156+ id="layer1">

157+ <rect

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"

159+ id="rect4136"

160+ width="201"

161+ height="69"

162+ x="116"

163+ y="203.3622"

164+ inkscape:export-xdpi="61.120499"

165+ inkscape:export-ydpi="61.120499" />

166+ <rect

167+ y="322.36218"

168+ x="113"

169+ height="69"

170+ width="201"

171+ id="rect4138"

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" />

175+ <rect

176+ y="202.3622"

177+ x="381"

178+ height="69"

179+ width="201"

180+ id="rect4140"

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" />

184+ <text

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"

187+ x="125"

188+ y="227.3622"

189+ id="text4142"

190+ sodipodi:linespacing="125%"

191+ inkscape:export-xdpi="61.120499"

192+ inkscape:export-ydpi="61.120499"><tspan

193+ sodipodi:role="line"

194+ id="tspan4144"

195+ x="125"

196+ y="227.3622">declareType</tspan></text>

197+ <text

198+ sodipodi:linespacing="125%"

199+ id="text4146"

200+ y="225.3622"

201+ x="389"

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

206+ y="225.3622"

207+ x="389"

208+ id="tspan4148"

209+ sodipodi:role="line">defineFunction</tspan></text>

210+ <path

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"

213+ id="path4150"

214+ inkscape:connector-curvature="0"

215+ inkscape:export-xdpi="61.120499"

216+ inkscape:export-ydpi="61.120499" />

217+ <text

218+ sodipodi:linespacing="125%"

219+ id="text5074"

220+ y="295.36218"

221+ x="201"

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

226+ y="295.36218"

227+ x="201"

228+ sodipodi:role="line"

229+ id="tspan5080"

230+ style="font-size:15px;fill:#ff0000">Declare</tspan></text>

231+ <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"

234+ x="117"

235+ y="344.36218"

236+ id="text5082"

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"

242+ id="tspan5084"

243+ x="117"

244+ y="344.36218">name:TTName</tspan><tspan

245+ style="font-size:15px;fill:#0000ff"

246+ id="tspan5086"

247+ sodipodi:role="line"

248+ x="117"

249+ y="363.11218">arguments:List FunArg</tspan><tspan

250+ style="font-size:15px;fill:#0000ff"

251+ id="tspan5088"

252+ sodipodi:role="line"

253+ x="117"

254+ y="381.86218">returnType:Raw</tspan></text>

255+ <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;"

258+ x="111"

259+ y="313.36218"

260+ id="text5095"

261+ sodipodi:linespacing="125%"

262+ inkscape:export-xdpi="61.120499"

263+ inkscape:export-ydpi="61.120499"><tspan

264+ style="font-size:15px;fill:#0000ff;"

265+ id="tspan5097"

266+ sodipodi:role="line"

267+ x="111"

268+ y="313.36218">TyDecl</tspan></text>

269+ <rect

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"

271+ id="rect5099"

272+ width="125"

273+ height="88"

274+ x="170"

275+ y="415.36218"

276+ inkscape:export-xdpi="61.120499"

277+ inkscape:export-ydpi="61.120499" />

278+ <path

279+ inkscape:connector-curvature="0"

280+ id="path5101"

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" />

285+ <text

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"

288+ x="260"

289+ y="408.36218"

290+ id="text5103"

291+ sodipodi:linespacing="125%"

292+ inkscape:export-xdpi="61.120499"

293+ inkscape:export-ydpi="61.120499"><tspan

294+ style="font-size:15px;fill:#ff0000"

295+ id="tspan5105"

296+ sodipodi:role="line"

297+ x="260"

298+ y="408.36218">MkFunArg</tspan></text>

299+ <text

300+ sodipodi:linespacing="125%"

301+ id="text5107"

302+ y="437.36218"

303+ x="174"

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

308+ y="437.36218"

309+ x="174"

310+ id="tspan5109"

311+ sodipodi:role="line"

312+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan

313+ y="456.11218"

314+ x="174"

315+ sodipodi:role="line"

316+ id="tspan5113"

317+ style="font-size:15px;fill:#0000ff">type:Raw</tspan><tspan

318+ y="474.86218"

319+ x="174"

320+ sodipodi:role="line"

321+ style="font-size:15px;fill:#0000ff"

322+ id="tspan5121">plicity:Plicity</tspan><tspan

323+ y="493.61218"

324+ x="174"

325+ sodipodi:role="line"

326+ style="font-size:15px;fill:#0000ff"

327+ id="tspan5123">erasure:Erasure</tspan></text>

328+ <text

329+ sodipodi:linespacing="125%"

330+ id="text5115"

331+ y="409.36218"

332+ x="170"

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

337+ y="409.36218"

338+ x="170"

339+ sodipodi:role="line"

340+ id="tspan5117"

341+ style="font-size:15px;fill:#0000ff">FunArg</tspan></text>

342+ <text

343+ sodipodi:linespacing="125%"

344+ id="text5125"

345+ y="526.36218"

346+ x="105"

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

351+ y="526.36218"

352+ x="105"

353+ sodipodi:role="line"

354+ id="tspan5127"

355+ style="font-size:15px;fill:#ff0000">Explicit</tspan><tspan

356+ y="545.11218"

357+ x="105"

358+ sodipodi:role="line"

359+ style="font-size:15px;fill:#ff0000"

360+ id="tspan5129">Implicit</tspan><tspan

361+ y="563.86218"

362+ x="105"

363+ sodipodi:role="line"

364+ style="font-size:15px;fill:#ff0000"

365+ id="tspan5131">Constraint</tspan></text>

366+ <path

367+ inkscape:connector-curvature="0"

368+ id="path5161"

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" />

374+ <path

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"

377+ id="path6319"

378+ inkscape:connector-curvature="0"

379+ sodipodi:nodetypes="cc"

380+ inkscape:export-xdpi="61.120499"

381+ inkscape:export-ydpi="61.120499" />

382+ <text

383+ sodipodi:linespacing="125%"

384+ id="text6321"

385+ y="544.36218"

386+ x="221"

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

391+ y="544.36218"

392+ x="221"

393+ sodipodi:role="line"

394+ id="tspan6323"

395+ style="font-size:15px;fill:#ff0000">Erased</tspan><tspan

396+ y="563.11218"

397+ x="221"

398+ sodipodi:role="line"

399+ style="font-size:15px;fill:#ff0000"

400+ id="tspan6773">NotErased</tspan></text>

401+ <rect

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"

403+ id="rect6775"

404+ width="247"

405+ height="49"

406+ x="347"

407+ y="322.36218"

408+ inkscape:export-xdpi="61.120499"

409+ inkscape:export-ydpi="61.120499" />

410+ <path

411+ inkscape:connector-curvature="0"

412+ id="path6777"

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" />

417+ <text

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"

420+ x="469"

421+ y="295.36218"

422+ id="text6779"

423+ sodipodi:linespacing="125%"

424+ inkscape:export-xdpi="61.120499"

425+ inkscape:export-ydpi="61.120499"><tspan

426+ style="font-size:15px;fill:#ff0000"

427+ id="tspan6781"

428+ sodipodi:role="line"

429+ x="469"

430+ y="295.36218">DefineFun</tspan></text>

431+ <text

432+ sodipodi:linespacing="125%"

433+ id="text6783"

434+ y="344.36218"

435+ x="351"

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

440+ y="344.36218"

441+ x="351"

442+ sodipodi:role="line"

443+ id="tspan6789"

444+ style="font-size:15px;fill:#0000ff">name:TTName</tspan><tspan

445+ y="363.11218"

446+ x="351"

447+ sodipodi:role="line"

448+ style="font-size:15px;fill:#0000ff"

449+ id="tspan7130">clauses : List (FunClause a)</tspan></text>

450+ <text

451+ sodipodi:linespacing="125%"

452+ id="text6791"

453+ y="313.36218"

454+ x="379"

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

459+ y="313.36218"

460+ x="379"

461+ sodipodi:role="line"

462+ id="tspan6793"

463+ style="font-size:15px;fill:#0000ff">FunDefn</tspan></text>

464+ <rect

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"

466+ id="rect6799"

467+ width="86"

468+ height="64"

469+ x="372"

470+ y="462.36218"

471+ inkscape:export-xdpi="61.120499"

472+ inkscape:export-ydpi="61.120499" />

473+ <path

474+ inkscape:connector-curvature="0"

475+ id="path6801"

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" />

481+ <text

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"

484+ x="352"

485+ y="418.36218"

486+ id="text6803"

487+ sodipodi:linespacing="125%"

488+ inkscape:export-xdpi="61.120499"

489+ inkscape:export-ydpi="61.120499"><tspan

490+ style="font-size:15px;fill:#ff0000"

491+ id="tspan6805"

492+ sodipodi:role="line"

493+ x="352"

494+ y="418.36218">MkFunClause</tspan></text>

495+ <text

496+ sodipodi:linespacing="125%"

497+ id="text6807"

498+ y="484.36218"

499+ x="376"

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

504+ y="484.36218"

505+ x="376"

506+ sodipodi:role="line"

507+ id="tspan6813"

508+ style="font-size:15px;fill:#0000ff">lhs:a</tspan><tspan

509+ y="503.11218"

510+ x="376"

511+ sodipodi:role="line"

512+ style="font-size:15px;fill:#0000ff"

513+ id="tspan4330">rhs:a</tspan></text>

514+ <text

515+ sodipodi:linespacing="125%"

516+ id="text6815"

517+ y="453.36218"

518+ x="370"

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

523+ y="453.36218"

524+ x="370"

525+ sodipodi:role="line"

526+ id="tspan6817"

527+ style="font-size:15px;fill:#0000ff">FunClause</tspan></text>

528+ <text

529+ inkscape:export-ydpi="61.120499"

530+ inkscape:export-xdpi="61.120499"

531+ sodipodi:linespacing="125%"

532+ id="text4321"

533+ y="395.36218"

534+ x="407"

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

537+ y="395.36218"

538+ x="407"

539+ sodipodi:role="line"

540+ id="tspan4323"

541+ style="font-size:15px;fill:#ff0000">MkImpossibleClause</tspan></text>

542+ <rect

543+ inkscape:export-ydpi="61.120499"

544+ inkscape:export-xdpi="61.120499"

545+ y="461.36218"

546+ x="473"

547+ height="64"

548+ width="86"

549+ id="rect4332"

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" />

551+ <text

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"

556+ x="477"

557+ y="483.36218"

558+ id="text4334"

559+ sodipodi:linespacing="125%"><tspan

560+ id="tspan4338"

561+ style="font-size:15px;fill:#0000ff"

562+ sodipodi:role="line"

563+ x="477"

564+ y="483.36218">lhs:a</tspan></text>

565+ <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"

570+ x="471"

571+ y="452.36218"

572+ id="text4340"

573+ sodipodi:linespacing="125%"><tspan

574+ style="font-size:15px;fill:#0000ff"

575+ id="tspan4342"

576+ sodipodi:role="line"

577+ x="471"

578+ y="452.36218">FunClause</tspan></text>

579+ <path

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"

584+ id="path4346"

585+ inkscape:connector-curvature="0"

586+ sodipodi:nodetypes="cc" />

587+ </g>

588+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="generateFunction2.svg">

19+ <defs

20+ id="defs4">

21+ <marker

22+ inkscape:isstock="true"

23+ style="overflow:visible;"

24+ id="marker4439"

25+ refX="0.0"

26+ refY="0.0"

27+ orient="auto"

28+ inkscape:stockid="Arrow2Mend">

29+ <path

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"

33+ id="path4441" />

34+ </marker>

35+ <marker

36+ inkscape:stockid="Arrow2Mend"

37+ orient="auto"

38+ refY="0.0"

39+ refX="0.0"

40+ id="marker4433"

41+ style="overflow:visible;"

42+ inkscape:isstock="true">

43+ <path

44+ id="path4435"

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)" />

48+ </marker>

49+ <marker

50+ inkscape:isstock="true"

51+ style="overflow:visible;"

52+ id="marker4427"

53+ refX="0.0"

54+ refY="0.0"

55+ orient="auto"

56+ inkscape:stockid="Arrow2Mend"

57+ inkscape:collect="always">

58+ <path

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"

62+ id="path4429" />

63+ </marker>

64+ <marker

65+ inkscape:isstock="true"

66+ style="overflow:visible;"

67+ id="marker4411"

68+ refX="0.0"

69+ refY="0.0"

70+ orient="auto"

71+ inkscape:stockid="Arrow2Mend">

72+ <path

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"

76+ id="path4413" />

77+ </marker>

78+ <marker

79+ inkscape:stockid="Arrow2Mend"

80+ orient="auto"

81+ refY="0.0"

82+ refX="0.0"

83+ id="marker4407"

84+ style="overflow:visible;"

85+ inkscape:isstock="true">

86+ <path

87+ id="path4409"

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)" />

91+ </marker>

92+ <marker

93+ inkscape:stockid="Arrow2Mend"

94+ orient="auto"

95+ refY="0.0"

96+ refX="0.0"

97+ id="marker4403"

98+ style="overflow:visible;"

99+ inkscape:isstock="true">

100+ <path

101+ id="path4405"

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)" />

105+ </marker>

106+ <marker

107+ inkscape:isstock="true"

108+ style="overflow:visible;"

109+ id="marker4359"

110+ refX="0.0"

111+ refY="0.0"

112+ orient="auto"

113+ inkscape:stockid="Arrow2Mend"

114+ inkscape:collect="always">

115+ <path

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"

119+ id="path4361" />

120+ </marker>

121+ <marker

122+ inkscape:stockid="Arrow2Mend"

123+ orient="auto"

124+ refY="0.0"

125+ refX="0.0"

126+ id="marker4349"

127+ style="overflow:visible;"

128+ inkscape:isstock="true"

129+ inkscape:collect="always">

130+ <path

131+ id="path4351"

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)" />

135+ </marker>

136+ <marker

137+ inkscape:isstock="true"

138+ style="overflow:visible;"

139+ id="marker7147"

140+ refX="0.0"

141+ refY="0.0"

142+ orient="auto"

143+ inkscape:stockid="Arrow2Mend">

144+ <path

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"

148+ id="path7149" />

149+ </marker>

150+ <marker

151+ inkscape:isstock="true"

152+ style="overflow:visible;"

153+ id="marker6325"

154+ refX="0.0"

155+ refY="0.0"

156+ orient="auto"

157+ inkscape:stockid="Arrow2Mend">

158+ <path

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"

162+ id="path6327" />

163+ </marker>

164+ <marker

165+ inkscape:stockid="Arrow2Mend"

166+ orient="auto"

167+ refY="0.0"

168+ refX="0.0"

169+ id="marker5163"

170+ style="overflow:visible;"

171+ inkscape:isstock="true">

172+ <path

173+ id="path5165"

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)" />

177+ </marker>

178+ </defs>

179+ <sodipodi:namedview

180+ id="base"

181+ pagecolor="#ffffff"

182+ bordercolor="#666666"

183+ borderopacity="1.0"

184+ inkscape:pageopacity="0.0"

185+ inkscape:pageshadow="2"

186+ inkscape:zoom="1"

187+ inkscape:cx="380.92935"

188+ inkscape:cy="592.42473"

189+ inkscape:document-units="px"

190+ inkscape:current-layer="layer1"

191+ showgrid="false"

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" />

197+ <metadata

198+ id="metadata7">

199+ <rdf:RDF>

200+ <cc:Work

201+ rdf:about="">

202+ <dc:format>image/svg+xml</dc:format>

203+ <dc:type

204+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

205+ <dc:title />

206+ </cc:Work>

207+ </rdf:RDF>

208+ </metadata>

209+ <g

210+ inkscape:label="Layer 1"

211+ inkscape:groupmode="layer"

212+ id="layer1">

213+ <rect

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"

215+ id="rect6799"

216+ width="86"

217+ height="64"

218+ x="203"

219+ y="105.36218"

220+ inkscape:export-xdpi="61.120499"

221+ inkscape:export-ydpi="61.120499" />

222+ <text

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"

225+ x="201"

226+ y="211.36218"

227+ id="text6803"

228+ sodipodi:linespacing="125%"

229+ inkscape:export-xdpi="61.120499"

230+ inkscape:export-ydpi="61.120499"><tspan

231+ style="font-size:15px;fill:#ff0000"

232+ id="tspan6805"

233+ sodipodi:role="line"

234+ x="201"

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>

242+ <text

243+ sodipodi:linespacing="125%"

244+ id="text6807"

245+ y="127.36218"

246+ x="207"

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

251+ y="127.36218"

252+ x="207"

253+ sodipodi:role="line"

254+ id="tspan6813"

255+ style="font-size:15px;fill:#0000ff">lhs:a</tspan><tspan

256+ y="146.11218"

257+ x="207"

258+ sodipodi:role="line"

259+ style="font-size:15px;fill:#0000ff"

260+ id="tspan4330">rhs:a</tspan></text>

261+ <text

262+ sodipodi:linespacing="125%"

263+ id="text6815"

264+ y="96.362183"

265+ x="201"

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

270+ y="96.362183"

271+ x="201"

272+ sodipodi:role="line"

273+ id="tspan6817"

274+ style="font-size:15px;fill:#0000ff">FunClause</tspan></text>

275+ <rect

276+ inkscape:export-ydpi="61.120499"

277+ inkscape:export-xdpi="61.120499"

278+ y="177.36218"

279+ x="153"

280+ height="142"

281+ width="350"

282+ id="rect4332"

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" />

284+ <text

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"

289+ x="162"

290+ y="168.36218"

291+ id="text4340"

292+ sodipodi:linespacing="125%"><tspan

293+ style="font-size:15px;fill:#0000ff"

294+ id="tspan4342"

295+ sodipodi:role="line"

296+ x="162"

297+ y="168.36218">Raw</tspan></text>

298+ <path

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"

303+ id="path4346"

304+ inkscape:connector-curvature="0"

305+ sodipodi:nodetypes="cc" />

306+ <text

307+ inkscape:export-ydpi="61.120499"

308+ inkscape:export-xdpi="61.120499"

309+ sodipodi:linespacing="125%"

310+ id="text4333"

311+ y="362.36218"

312+ x="343"

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

315+ y="362.36218"

316+ x="343"

317+ sodipodi:role="line"

318+ id="tspan4335"

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>

324+ <path

325+ sodipodi:nodetypes="cc"

326+ inkscape:connector-curvature="0"

327+ id="path4337"

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" />

332+ <text

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"

335+ x="439"

336+ y="196.36218"

337+ id="text4339"

338+ sodipodi:linespacing="125%"

339+ inkscape:export-xdpi="61.120499"

340+ inkscape:export-ydpi="61.120499"><tspan

341+ style="font-size:15px;fill:#ff0000"

342+ id="tspan4341"

343+ sodipodi:role="line"

344+ x="439"

345+ y="196.36218">RApp Raw Raw</tspan></text>

346+ <path

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"

351+ id="path4343"

352+ inkscape:connector-curvature="0"

353+ sodipodi:nodetypes="cc" />

354+ <rect

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"

356+ id="rect4381"

357+ width="314"

358+ height="63"

359+ x="152"

360+ y="373.36218"

361+ inkscape:export-xdpi="61.120499"

362+ inkscape:export-ydpi="61.120499" />

363+ <text

364+ sodipodi:linespacing="125%"

365+ id="text4383"

366+ y="364.36218"

367+ x="161"

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

372+ y="364.36218"

373+ x="161"

374+ sodipodi:role="line"

375+ id="tspan4385"

376+ style="font-size:15px;fill:#0000ff">Binder a</tspan></text>

377+ <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"

380+ x="208"

381+ y="254.36218"

382+ id="text4417"

383+ sodipodi:linespacing="125%"

384+ inkscape:export-xdpi="61.120499"

385+ inkscape:export-ydpi="61.120499"><tspan

386+ style="font-size:15px;fill:#ff0000"

387+ id="tspan4419"

388+ sodipodi:role="line"

389+ x="208"

390+ y="254.36218">`{{code}}</tspan></text>

391+ <text

392+ inkscape:export-ydpi="61.120499"

393+ inkscape:export-xdpi="61.120499"

394+ sodipodi:linespacing="125%"

395+ id="text4421"

396+ y="275.36218"

397+ x="242"

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

400+ y="275.36218"

401+ x="242"

402+ sodipodi:role="line"

403+ id="tspan4423"

404+ style="font-size:15px;fill:#ff0000">`{{body}}</tspan></text>

405+ <path

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"

410+ id="path4425"

411+ inkscape:connector-curvature="0"

412+ sodipodi:nodetypes="cc" />

413+ <path

414+ sodipodi:nodetypes="cc"

415+ inkscape:connector-curvature="0"

416+ id="path4431"

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" />

421+ <path

422+ sodipodi:nodetypes="cc"

423+ inkscape:connector-curvature="0"

424+ id="path4437"

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" />

429+ </g>

430+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="idrisTopLevel.svg">

19+ <defs

20+ id="defs4">

21+ <marker

22+ inkscape:stockid="Arrow1Mend"

23+ orient="auto"

24+ refY="0.0"

25+ refX="0.0"

26+ id="marker4198"

27+ style="overflow:visible;"

28+ inkscape:isstock="true">

29+ <path

30+ id="path4200"

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)" />

34+ </marker>

35+ <marker

36+ inkscape:isstock="true"

37+ style="overflow:visible;"

38+ id="marker4203"

39+ refX="0.0"

40+ refY="0.0"

41+ orient="auto"

42+ inkscape:stockid="Arrow1Mend"

43+ inkscape:collect="always">

44+ <path

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 "

48+ id="path4205" />

49+ </marker>

50+ <marker

51+ inkscape:stockid="Arrow1Mend"

52+ orient="auto"

53+ refY="0.0"

54+ refX="0.0"

55+ id="marker4197"

56+ style="overflow:visible;"

57+ inkscape:isstock="true"

58+ inkscape:collect="always">

59+ <path

60+ id="path4199"

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)" />

64+ </marker>

65+ <marker

66+ inkscape:stockid="Arrow1Mend"

67+ orient="auto"

68+ refY="0.0"

69+ refX="0.0"

70+ id="marker4182"

71+ style="overflow:visible;"

72+ inkscape:isstock="true">

73+ <path

74+ id="path4184"

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)" />

78+ </marker>

79+ <marker

80+ inkscape:isstock="true"

81+ style="overflow:visible;"

82+ id="marker4176"

83+ refX="0.0"

84+ refY="0.0"

85+ orient="auto"

86+ inkscape:stockid="Arrow1Mend"

87+ inkscape:collect="always">

88+ <path

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 "

92+ id="path4178" />

93+ </marker>

94+ <marker

95+ inkscape:stockid="Arrow1Mend"

96+ orient="auto"

97+ refY="0.0"

98+ refX="0.0"

99+ id="marker4830"

100+ style="overflow:visible;"

101+ inkscape:isstock="true"

102+ inkscape:collect="always">

103+ <path

104+ id="path4832"

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)" />

108+ </marker>

109+ <marker

110+ inkscape:stockid="Arrow1Mend"

111+ orient="auto"

112+ refY="0.0"

113+ refX="0.0"

114+ id="Arrow1Mend"

115+ style="overflow:visible;"

116+ inkscape:isstock="true"

117+ inkscape:collect="always">

118+ <path

119+ id="path4175"

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)" />

123+ </marker>

124+ </defs>

125+ <sodipodi:namedview

126+ id="base"

127+ pagecolor="#ffffff"

128+ bordercolor="#666666"

129+ borderopacity="1.0"

130+ inkscape:pageopacity="0.0"

131+ inkscape:pageshadow="2"

132+ inkscape:zoom="1"

133+ inkscape:cx="353.5"

134+ inkscape:cy="669.5"

135+ inkscape:document-units="px"

136+ inkscape:current-layer="layer1"

137+ showgrid="false"

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" />

143+ <metadata

144+ id="metadata7">

145+ <rdf:RDF>

146+ <cc:Work

147+ rdf:about="">

148+ <dc:format>image/svg+xml</dc:format>

149+ <dc:type

150+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

151+ <dc:title />

152+ </cc:Work>

153+ </rdf:RDF>

154+ </metadata>

155+ <g

156+ inkscape:label="Layer 1"

157+ inkscape:groupmode="layer"

158+ id="layer1">

159+ <text

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"

162+ x="21"

163+ y="411.36221"

164+ id="text4136"

165+ sodipodi:linespacing="125%"

166+ inkscape:export-xdpi="61.120499"

167+ inkscape:export-ydpi="61.120499"><tspan

168+ sodipodi:role="line"

169+ id="tspan4138"

170+ x="21"

171+ y="411.36221"

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>

173+ <text

174+ sodipodi:linespacing="125%"

175+ id="text4140"

176+ y="411.36221"

177+ x="203"

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"

183+ y="411.36221"

184+ x="203"

185+ id="tspan4142"

186+ sodipodi:role="line">Idris</tspan></text>

187+ <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;"

190+ x="253"

191+ y="402.36218"

192+ id="text4144"

193+ sodipodi:linespacing="125%"

194+ inkscape:export-xdpi="61.120499"

195+ inkscape:export-ydpi="61.120499"><tspan

196+ sodipodi:role="line"

197+ id="tspan4146"

198+ x="253"

199+ y="402.36218"

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>

201+ <text

202+ sodipodi:linespacing="125%"

203+ id="text4148"

204+ y="411.60635"

205+ x="451"

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"

211+ y="411.60635"

212+ x="451"

213+ id="tspan4150"

214+ sodipodi:role="line">TT</tspan></text>

215+ <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"

218+ x="610"

219+ y="411.36221"

220+ id="text4152"

221+ sodipodi:linespacing="125%"

222+ inkscape:export-xdpi="61.120499"

223+ inkscape:export-ydpi="61.120499"><tspan

224+ sodipodi:role="line"

225+ id="tspan4154"

226+ x="610"

227+ y="411.36221"

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>

229+ <text

230+ sodipodi:linespacing="125%"

231+ id="text4156"

232+ y="436.36218"

233+ x="80"

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'"

239+ y="436.36218"

240+ x="80"

241+ id="tspan4158"

242+ sodipodi:role="line">desugaring</tspan></text>

243+ <path

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"

246+ id="path4160"

247+ inkscape:connector-curvature="0"

248+ inkscape:export-xdpi="61.120499"

249+ inkscape:export-ydpi="61.120499"

250+ sodipodi:nodetypes="cc" />

251+ <text

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"

254+ x="281"

255+ y="432.36218"

256+ id="text4790"

257+ sodipodi:linespacing="125%"

258+ inkscape:export-xdpi="61.120499"

259+ inkscape:export-ydpi="61.120499"><tspan

260+ sodipodi:role="line"

261+ id="tspan4792"

262+ x="281"

263+ y="432.36218"

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>

265+ <text

266+ sodipodi:linespacing="125%"

267+ id="text4824"

268+ y="394.36218"

269+ x="498"

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'"

275+ y="394.36218"

276+ x="498"

277+ id="tspan4826"

278+ sodipodi:role="line">compilation</tspan></text>

279+ <path

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"

282+ id="path4828"

283+ inkscape:connector-curvature="0"

284+ inkscape:export-xdpi="61.120499"

285+ inkscape:export-ydpi="61.120499"

286+ sodipodi:nodetypes="cc" />

287+ <text

288+ inkscape:export-ydpi="61.120499"

289+ inkscape:export-xdpi="61.120499"

290+ sodipodi:linespacing="125%"

291+ id="text4166"

292+ y="442.36218"

293+ x="609"

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"

297+ y="442.36218"

298+ x="609"

299+ id="tspan4168"

300+ sodipodi:role="line">C</tspan></text>

301+ <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"

304+ x="609"

305+ y="475.36218"

306+ id="text4170"

307+ sodipodi:linespacing="125%"

308+ inkscape:export-xdpi="61.120499"

309+ inkscape:export-ydpi="61.120499"><tspan

310+ sodipodi:role="line"

311+ id="tspan4172"

312+ x="609"

313+ y="475.36218"

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>

315+ <path

316+ inkscape:export-ydpi="61.120499"

317+ inkscape:export-xdpi="61.120499"

318+ inkscape:connector-curvature="0"

319+ id="path4174"

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" />

323+ <path

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"

327+ id="path4180"

328+ inkscape:connector-curvature="0"

329+ inkscape:export-xdpi="61.120499"

330+ inkscape:export-ydpi="61.120499" />

331+ <text

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"

336+ x="20"

337+ y="523.36218"

338+ id="text4186"

339+ sodipodi:linespacing="125%"><tspan

340+ sodipodi:role="line"

341+ x="20"

342+ y="523.36218"

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"

346+ x="20"

347+ y="542.11218"

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>

350+ <path

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"

353+ id="path4192"

354+ inkscape:connector-curvature="0"

355+ inkscape:export-xdpi="61.120499"

356+ inkscape:export-ydpi="61.120499"

357+ sodipodi:nodetypes="cc" />

358+ <text

359+ sodipodi:linespacing="125%"

360+ id="text4194"

361+ y="367.36218"

362+ x="358"

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

367+ id="tspan4198"

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'"

369+ y="367.36218"

370+ x="358"

371+ sodipodi:role="line">proof tactics</tspan></text>

372+ <path

373+ inkscape:connector-curvature="0"

374+ id="path4202"

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" />

380+ <path

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"

385+ id="path4195"

386+ inkscape:connector-curvature="0"

387+ sodipodi:nodetypes="cc" />

388+ <path

389+ sodipodi:nodetypes="cc"

390+ inkscape:connector-curvature="0"

391+ id="path4201"

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" />

396+ <text

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"

401+ x="215"

402+ y="340.36218"

403+ id="text4207"

404+ sodipodi:linespacing="125%"><tspan

405+ sodipodi:role="line"

406+ x="215"

407+ y="340.36218"

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"

411+ x="215"

412+ y="359.11218"

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"

416+ x="215"

417+ y="377.86218"

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>

420+ <path

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"

426+ id="path4211"

427+ inkscape:connector-curvature="0" />

428+ <text

429+ sodipodi:linespacing="125%"

430+ id="text4215"

431+ y="461.36218"

432+ x="233"

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

437+ id="tspan4217"

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'"

439+ y="461.36218"

440+ x="233"

441+ sodipodi:role="line">Make explicit all types.</tspan><tspan

442+ id="tspan4223"

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'"

444+ y="480.11218"

445+ x="233"

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'"

448+ y="498.86218"

449+ x="233"

450+ sodipodi:role="line"

451+ id="tspan4235"> pattern match variables.</tspan></text>

452+ <path

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"

458+ id="path4237"

459+ inkscape:connector-curvature="0" />

460+ <path

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"

465+ id="path4196"

466+ inkscape:connector-curvature="0"

467+ sodipodi:nodetypes="cc" />

468+ <text

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"

473+ x="431"

474+ y="465.36218"

475+ id="text4202"

476+ sodipodi:linespacing="125%"><tspan

477+ sodipodi:role="line"

478+ x="431"

479+ y="465.36218"

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"

483+ x="431"

484+ y="484.11218"

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 -&gt; TT</tspan></text>

487+ <path

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"

493+ id="path4206"

494+ inkscape:connector-curvature="0" />

495+ <text

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"

500+ x="378"

501+ y="417.36218"

502+ id="text4203"

503+ sodipodi:linespacing="125%"><tspan

504+ sodipodi:role="line"

505+ id="tspan4205"

506+ x="378"

507+ y="417.36218"

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>

509+ <text

510+ sodipodi:linespacing="125%"

511+ id="text4205"

512+ y="432.36218"

513+ x="201"

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"

519+ y="432.36218"

520+ x="201"

521+ id="tspan4207"

522+ sodipodi:role="line">PTerm</tspan></text>

523+ </g>

524+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 210 297"

15+ version="1.1"

16+ id="svg8"

17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"

18+ sodipodi:docname="parserModules.svg">

19+ <defs

20+ id="defs2">

21+ <marker

22+ inkscape:isstock="true"

23+ style="overflow:visible;"

24+ id="marker1078"

25+ refX="0.0"

26+ refY="0.0"

27+ orient="auto"

28+ inkscape:stockid="Arrow1Mend">

29+ <path

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 "

33+ id="path1076" />

34+ </marker>

35+ <marker

36+ inkscape:isstock="true"

37+ style="overflow:visible"

38+ id="marker1074"

39+ refX="0.0"

40+ refY="0.0"

41+ orient="auto"

42+ inkscape:stockid="Arrow1Mstart">

43+ <path

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 "

47+ id="path1072" />

48+ </marker>

49+ <marker

50+ inkscape:stockid="Arrow1Mend"

51+ orient="auto"

52+ refY="0.0"

53+ refX="0.0"

54+ id="marker1021"

55+ style="overflow:visible;"

56+ inkscape:isstock="true"

57+ inkscape:collect="always">

58+ <path

59+ id="path1019"

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)" />

63+ </marker>

64+ <marker

65+ inkscape:stockid="Arrow1Mstart"

66+ orient="auto"

67+ refY="0.0"

68+ refX="0.0"

69+ id="marker1017"

70+ style="overflow:visible"

71+ inkscape:isstock="true"

72+ inkscape:collect="always">

73+ <path

74+ id="path1015"

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)" />

78+ </marker>

79+ <marker

80+ inkscape:isstock="true"

81+ style="overflow:visible;"

82+ id="marker973"

83+ refX="0.0"

84+ refY="0.0"

85+ orient="auto"

86+ inkscape:stockid="Arrow1Mend"

87+ inkscape:collect="always">

88+ <path

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 "

92+ id="path971" />

93+ </marker>

94+ <marker

95+ inkscape:isstock="true"

96+ style="overflow:visible"

97+ id="marker969"

98+ refX="0.0"

99+ refY="0.0"

100+ orient="auto"

101+ inkscape:stockid="Arrow1Mstart"

102+ inkscape:collect="always">

103+ <path

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 "

107+ id="path967" />

108+ </marker>

109+ <marker

110+ inkscape:stockid="Arrow1Mend"

111+ orient="auto"

112+ refY="0.0"

113+ refX="0.0"

114+ id="Arrow1Mend"

115+ style="overflow:visible;"

116+ inkscape:isstock="true"

117+ inkscape:collect="always">

118+ <path

119+ id="path1214"

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)" />

123+ </marker>

124+ <marker

125+ inkscape:stockid="Arrow1Mstart"

126+ orient="auto"

127+ refY="0.0"

128+ refX="0.0"

129+ id="Arrow1Mstart"

130+ style="overflow:visible"

131+ inkscape:isstock="true"

132+ inkscape:collect="always">

133+ <path

134+ id="path1211"

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)" />

138+ </marker>

139+ <marker

140+ inkscape:isstock="true"

141+ style="overflow:visible;"

142+ id="marker1000"

143+ refX="0.0"

144+ refY="0.0"

145+ orient="auto"

146+ inkscape:stockid="Arrow1Mend">

147+ <path

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 "

151+ id="path998" />

152+ </marker>

153+ <marker

154+ inkscape:isstock="true"

155+ style="overflow:visible;"

156+ id="marker1127"

157+ refX="0.0"

158+ refY="0.0"

159+ orient="auto"

160+ inkscape:stockid="Arrow1Mend">

161+ <path

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 "

165+ id="path1125" />

166+ </marker>

167+ <marker

168+ inkscape:isstock="true"

169+ style="overflow:visible;"

170+ id="marker1123"

171+ refX="0.0"

172+ refY="0.0"

173+ orient="auto"

174+ inkscape:stockid="Arrow1Mend">

175+ <path

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 "

179+ id="path1121" />

180+ </marker>

181+ <marker

182+ inkscape:isstock="true"

183+ style="overflow:visible;"

184+ id="marker1117"

185+ refX="0.0"

186+ refY="0.0"

187+ orient="auto"

188+ inkscape:stockid="Arrow1Mend">

189+ <path

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 "

193+ id="path1115" />

194+ </marker>

195+ <marker

196+ inkscape:stockid="Arrow1Mend"

197+ orient="auto"

198+ refY="0.0"

199+ refX="0.0"

200+ id="marker1111"

201+ style="overflow:visible;"

202+ inkscape:isstock="true"

203+ inkscape:collect="always">

204+ <path

205+ id="path1109"

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)" />

209+ </marker>

210+ <marker

211+ inkscape:isstock="true"

212+ style="overflow:visible;"

213+ id="marker1105"

214+ refX="0.0"

215+ refY="0.0"

216+ orient="auto"

217+ inkscape:stockid="Arrow1Mend"

218+ inkscape:collect="always">

219+ <path

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 "

223+ id="path1103" />

224+ </marker>

225+ <marker

226+ inkscape:isstock="true"

227+ style="overflow:visible;"

228+ id="marker1057"

229+ refX="0.0"

230+ refY="0.0"

231+ orient="auto"

232+ inkscape:stockid="Arrow1Mend">

233+ <path

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 "

237+ id="path1055" />

238+ </marker>

239+ <marker

240+ inkscape:stockid="Arrow1Mend"

241+ orient="auto"

242+ refY="0.0"

243+ refX="0.0"

244+ id="marker1045"

245+ style="overflow:visible;"

246+ inkscape:isstock="true"

247+ inkscape:collect="always">

248+ <path

249+ id="path1043"

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)" />

253+ </marker>

254+ <marker

255+ inkscape:stockid="Arrow1Mend"

256+ orient="auto"

257+ refY="0.0"

258+ refX="0.0"

259+ id="marker1033"

260+ style="overflow:visible;"

261+ inkscape:isstock="true">

262+ <path

263+ id="path1031"

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)" />

267+ </marker>

268+ <marker

269+ inkscape:stockid="Arrow1Mend"

270+ orient="auto"

271+ refY="0.0"

272+ refX="0.0"

273+ id="marker1027"

274+ style="overflow:visible;"

275+ inkscape:isstock="true">

276+ <path

277+ id="path1025"

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)" />

281+ </marker>

282+ <marker

283+ inkscape:isstock="true"

284+ style="overflow:visible;"

285+ id="marker1015"

286+ refX="0.0"

287+ refY="0.0"

288+ orient="auto"

289+ inkscape:stockid="Arrow1Mend"

290+ inkscape:collect="always">

291+ <path

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 "

295+ id="path1013" />

296+ </marker>

297+ <marker

298+ inkscape:isstock="true"

299+ style="overflow:visible;"

300+ id="marker1009"

301+ refX="0.0"

302+ refY="0.0"

303+ orient="auto"

304+ inkscape:stockid="Arrow1Mend">

305+ <path

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 "

309+ id="path1007" />

310+ </marker>

311+ <marker

312+ inkscape:isstock="true"

313+ style="overflow:visible;"

314+ id="marker1003"

315+ refX="0.0"

316+ refY="0.0"

317+ orient="auto"

318+ inkscape:stockid="Arrow1Mend">

319+ <path

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 "

323+ id="path1001" />

324+ </marker>

325+ <marker

326+ inkscape:stockid="Arrow1Mend"

327+ orient="auto"

328+ refY="0.0"

329+ refX="0.0"

330+ id="marker997"

331+ style="overflow:visible;"

332+ inkscape:isstock="true"

333+ inkscape:collect="always">

334+ <path

335+ id="path995"

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)" />

339+ </marker>

340+ <marker

341+ inkscape:isstock="true"

342+ style="overflow:visible;"

343+ id="marker991"

344+ refX="0.0"

345+ refY="0.0"

346+ orient="auto"

347+ inkscape:stockid="Arrow1Mend"

348+ inkscape:collect="always">

349+ <path

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 "

353+ id="path989" />

354+ </marker>

355+ <marker

356+ inkscape:stockid="Arrow1Mend"

357+ orient="auto"

358+ refY="0.0"

359+ refX="0.0"

360+ id="marker967"

361+ style="overflow:visible;"

362+ inkscape:isstock="true"

363+ inkscape:collect="always">

364+ <path

365+ id="path965"

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)" />

369+ </marker>

370+ <marker

371+ inkscape:isstock="true"

372+ style="overflow:visible;"

373+ id="marker961"

374+ refX="0.0"

375+ refY="0.0"

376+ orient="auto"

377+ inkscape:stockid="Arrow1Mend"

378+ inkscape:collect="always">

379+ <path

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 "

383+ id="path959" />

384+ </marker>

385+ <marker

386+ inkscape:isstock="true"

387+ style="overflow:visible;"

388+ id="marker3617"

389+ refX="0.0"

390+ refY="0.0"

391+ orient="auto"

392+ inkscape:stockid="Arrow1Mend">

393+ <path

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 "

397+ id="path3615" />

398+ </marker>

399+ <marker

400+ inkscape:stockid="Arrow1Mend"

401+ orient="auto"

402+ refY="0.0"

403+ refX="0.0"

404+ id="marker2049"

405+ style="overflow:visible;"

406+ inkscape:isstock="true"

407+ inkscape:collect="always">

408+ <path

409+ id="path2047"

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)" />

413+ </marker>

414+ <marker

415+ inkscape:isstock="true"

416+ style="overflow:visible;"

417+ id="marker1539"

418+ refX="0.0"

419+ refY="0.0"

420+ orient="auto"

421+ inkscape:stockid="Arrow1Mend"

422+ inkscape:collect="always">

423+ <path

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 "

427+ id="path1537" />

428+ </marker>

429+ </defs>

430+ <sodipodi:namedview

431+ id="base"

432+ pagecolor="#ffffff"

433+ bordercolor="#666666"

434+ borderopacity="1.0"

435+ inkscape:pageopacity="0.0"

436+ inkscape:pageshadow="2"

437+ inkscape:zoom="1"

438+ inkscape:cx="368.33949"

439+ inkscape:cy="547.05121"

440+ inkscape:document-units="mm"

441+ inkscape:current-layer="layer1"

442+ showgrid="false"

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" />

449+ <metadata

450+ id="metadata5">

451+ <rdf:RDF>

452+ <cc:Work

453+ rdf:about="">

454+ <dc:format>image/svg+xml</dc:format>

455+ <dc:type

456+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

457+ <dc:title />

458+ </cc:Work>

459+ </rdf:RDF>

460+ </metadata>

461+ <g

462+ inkscape:label="Layer 1"

463+ inkscape:groupmode="layer"

464+ id="layer1">

465+ <text

466+ inkscape:export-ydpi="61.120499"

467+ inkscape:export-xdpi="61.120499"

468+ id="text854"

469+ y="119.72919"

470+ x="131.23334"

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"

474+ y="129.46077"

475+ x="131.23334"

476+ id="tspan852"

477+ sodipodi:role="line" /></text>

478+ <rect

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"

482+ id="rect875"

483+ width="43.656246"

484+ height="18.520832"

485+ x="92.339577"

486+ y="110.20418" />

487+ <path

488+ inkscape:export-ydpi="61.120499"

489+ inkscape:export-xdpi="61.120499"

490+ inkscape:connector-curvature="0"

491+ id="path881"

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)" />

494+ <text

495+ inkscape:export-ydpi="61.120499"

496+ inkscape:export-xdpi="61.120499"

497+ id="text895"

498+ y="115.76046"

499+ x="138.37698"

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"

503+ y="115.76046"

504+ x="138.37698"

505+ id="tspan893"

506+ sodipodi:role="line">PTerm</tspan></text>

507+ <text

508+ inkscape:export-ydpi="61.120499"

509+ inkscape:export-xdpi="61.120499"

510+ id="text903"

511+ y="115.23129"

512+ x="93.927078"

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"

516+ y="115.23129"

517+ x="93.927078"

518+ id="tspan901"

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"

521+ y="128.46045"

522+ x="93.927078"

523+ sodipodi:role="line"

524+ id="tspan1021" /></text>

525+ <rect

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"

527+ id="rect905"

528+ width="44.185421"

529+ height="18.785423"

530+ x="40.463421"

531+ y="141.50723"

532+ inkscape:export-xdpi="61.120499"

533+ inkscape:export-ydpi="61.120499" />

534+ <rect

535+ y="155.183"

536+ x="95.51458"

537+ height="18.256256"

538+ width="49.212498"

539+ id="rect907"

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" />

543+ <path

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"

546+ id="path909"

547+ inkscape:connector-curvature="0"

548+ inkscape:export-xdpi="61.120499"

549+ inkscape:export-ydpi="61.120499"

550+ sodipodi:nodetypes="cc" />

551+ <path

552+ inkscape:connector-curvature="0"

553+ id="path911"

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" />

558+ <text

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"

561+ x="24.059256"

562+ y="148.91547"

563+ id="text917"

564+ inkscape:export-xdpi="61.120499"

565+ inkscape:export-ydpi="61.120499"><tspan

566+ sodipodi:role="line"

567+ id="tspan915"

568+ x="24.059256"

569+ y="148.91547"

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>

571+ <text

572+ id="text923"

573+ y="137.72075"

574+ x="65.087494"

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"

580+ y="137.72075"

581+ x="65.087494"

582+ sodipodi:role="line"

583+ id="tspan921">List (TokenData Token)</tspan></text>

584+ <text

585+ id="text931"

586+ y="218.41846"

587+ x="36.512497"

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;"

593+ y="218.41846"

594+ x="36.512497"

595+ id="tspan929"

596+ sodipodi:role="line">module Text.Lexer</tspan></text>

597+ <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"

600+ x="98.160408"

601+ y="161.00386"

602+ id="text935"

603+ inkscape:export-xdpi="61.120499"

604+ inkscape:export-ydpi="61.120499"><tspan

605+ sodipodi:role="line"

606+ id="tspan933"

607+ x="98.160408"

608+ y="161.00386"

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>

610+ <rect

611+ inkscape:export-ydpi="61.120499"

612+ inkscape:export-xdpi="61.120499"

613+ y="214.18488"

614+ x="32.01458"

615+ height="6.3500061"

616+ width="43.656254"

617+ id="rect937"

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" />

619+ <rect

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"

623+ id="rect939"

624+ width="42.862495"

625+ height="6.8791728"

626+ x="94.985413"

627+ y="214.18488" />

628+ <text

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"

633+ x="42.31551"

634+ y="147.59224"

635+ id="text951"><tspan

636+ sodipodi:role="line"

637+ id="tspan949"

638+ x="42.31551"

639+ y="147.59224"

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>

641+ <path

642+ sodipodi:nodetypes="cc"

643+ inkscape:export-ydpi="61.120499"

644+ inkscape:export-xdpi="61.120499"

645+ inkscape:connector-curvature="0"

646+ id="path963"

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)" />

649+ <text

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;"

654+ x="23.220526"

655+ y="251.01649"

656+ id="text971"><tspan

657+ sodipodi:role="line"

658+ id="tspan969"

659+ x="23.220526"

660+ y="251.01649"

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>

662+ <rect

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"

664+ id="rect973"

665+ width="47.889587"

666+ height="6.3500061"

667+ x="21.633026"

668+ y="246.51833"

669+ inkscape:export-xdpi="61.120499"

670+ inkscape:export-ydpi="61.120499" />

671+ <path

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"

674+ id="path975"

675+ inkscape:connector-curvature="0"

676+ inkscape:export-xdpi="61.120499"

677+ inkscape:export-ydpi="61.120499"

678+ sodipodi:nodetypes="cc" />

679+ <text

680+ id="text979"

681+ y="241.96643"

682+ x="23.283329"

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;"

688+ y="241.96643"

689+ x="23.283329"

690+ id="tspan977"

691+ sodipodi:role="line">module Text.Quantity</tspan></text>

692+ <rect

693+ inkscape:export-ydpi="61.120499"

694+ inkscape:export-xdpi="61.120499"

695+ y="237.46826"

696+ x="21.695829"

697+ height="6.2469702"

698+ width="43.853985"

699+ id="rect981"

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" />

701+ <text

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;"

706+ x="23.18244"

707+ y="233.68523"

708+ id="text985"><tspan

709+ sodipodi:role="line"

710+ id="tspan983"

711+ x="23.18244"

712+ y="233.68523"

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>

714+ <rect

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"

716+ id="rect987"

717+ width="39.011257"

718+ height="5.9464455"

719+ x="21.59494"

720+ y="229.18706"

721+ inkscape:export-xdpi="61.120499"

722+ inkscape:export-ydpi="61.120499" />

723+ <path

724+ sodipodi:nodetypes="cc"

725+ inkscape:export-ydpi="61.120499"

726+ inkscape:export-xdpi="61.120499"

727+ inkscape:connector-curvature="0"

728+ id="path993"

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)" />

731+ <path

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"

734+ id="path999"

735+ inkscape:connector-curvature="0"

736+ inkscape:export-xdpi="61.120499"

737+ inkscape:export-ydpi="61.120499"

738+ sodipodi:nodetypes="cc" />

739+ <path

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"

742+ id="path1005"

743+ inkscape:connector-curvature="0"

744+ inkscape:export-xdpi="61.120499"

745+ inkscape:export-ydpi="61.120499"

746+ sodipodi:nodetypes="cc" />

747+ <path

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"

750+ id="path1011"

751+ inkscape:connector-curvature="0"

752+ inkscape:export-xdpi="61.120499"

753+ inkscape:export-ydpi="61.120499"

754+ sodipodi:nodetypes="cc" />

755+ <text

756+ inkscape:export-ydpi="61.120499"

757+ inkscape:export-xdpi="61.120499"

758+ id="text1019"

759+ y="218.94762"

760+ x="96.837494"

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;"

764+ y="218.94762"

765+ x="96.837494"

766+ id="tspan1017"

767+ sodipodi:role="line">module Text.Parser</tspan></text>

768+ <path

769+ sodipodi:nodetypes="cc"

770+ inkscape:export-ydpi="61.120499"

771+ inkscape:export-xdpi="61.120499"

772+ inkscape:connector-curvature="0"

773+ id="path1023"

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)" />

776+ <path

777+ sodipodi:nodetypes="cc"

778+ inkscape:export-ydpi="61.120499"

779+ inkscape:export-xdpi="61.120499"

780+ inkscape:connector-curvature="0"

781+ id="path1029"

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)" />

784+ <rect

785+ y="142.91107"

786+ x="118.15033"

787+ height="6.6968417"

788+ width="45.2328"

789+ id="rect1035"

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" />

793+ <path

794+ sodipodi:nodetypes="cc"

795+ inkscape:export-ydpi="61.120499"

796+ inkscape:export-xdpi="61.120499"

797+ inkscape:connector-curvature="0"

798+ id="path1037"

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)" />

801+ <text

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"

804+ x="120.00241"

805+ y="147.67372"

806+ id="text1041"

807+ inkscape:export-xdpi="61.120499"

808+ inkscape:export-ydpi="61.120499"><tspan

809+ sodipodi:role="line"

810+ id="tspan1039"

811+ x="120.00241"

812+ y="147.67372"

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>

814+ <rect

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"

818+ id="rect1047"

819+ width="42.862495"

820+ height="6.8791728"

821+ x="125.28364"

822+ y="133.0603" />

823+ <path

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"

826+ id="path1049"

827+ inkscape:connector-curvature="0"

828+ inkscape:export-xdpi="61.120499"

829+ inkscape:export-ydpi="61.120499"

830+ sodipodi:nodetypes="cc" />

831+ <text

832+ inkscape:export-ydpi="61.120499"

833+ inkscape:export-xdpi="61.120499"

834+ id="text1053"

835+ y="137.82295"

836+ x="127.13572"

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"

840+ y="137.82295"

841+ x="127.13572"

842+ id="tspan1051"

843+ sodipodi:role="line">module Idris.Syntax</tspan></text>

844+ <rect

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"

848+ id="rect1061"

849+ width="59.266659"

850+ height="16.13958"

851+ x="97.102074"

852+ y="186.93335" />

853+ <path

854+ inkscape:export-ydpi="61.120499"

855+ inkscape:export-xdpi="61.120499"

856+ inkscape:connector-curvature="0"

857+ id="path1063"

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" />

861+ <text

862+ inkscape:export-ydpi="61.120499"

863+ inkscape:export-xdpi="61.120499"

864+ id="text1081"

865+ y="192.48962"

866+ x="157.95586"

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"

870+ y="192.48962"

871+ x="157.95586"

872+ id="tspan1079"

873+ sodipodi:role="line">SExp</tspan></text>

874+ <text

875+ inkscape:export-ydpi="61.120499"

876+ inkscape:export-xdpi="61.120499"

877+ id="text1089"

878+ y="192.75421"

879+ x="98.954155"

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"

883+ y="192.75421"

884+ x="98.954155"

885+ id="tspan1087"

886+ sodipodi:role="line">module Idris.IDEMode.Parser</tspan></text>

887+ <rect

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"

891+ id="rect1097"

892+ width="55.033333"

893+ height="14.287498"

894+ x="20.637447"

895+ y="52.524986" />

896+ <text

897+ inkscape:export-ydpi="61.120499"

898+ inkscape:export-xdpi="61.120499"

899+ id="text1101"

900+ y="58.610428"

901+ x="23.54781"

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;"

905+ y="58.610428"

906+ x="23.54781"

907+ id="tspan1099"

908+ sodipodi:role="line">module Idris.REPL</tspan></text>

909+ <path

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"

913+ id="path1107"

914+ inkscape:connector-curvature="0"

915+ inkscape:export-xdpi="61.120499"

916+ inkscape:export-ydpi="61.120499" />

917+ <path

918+ inkscape:export-ydpi="61.120499"

919+ inkscape:export-xdpi="61.120499"

920+ inkscape:connector-curvature="0"

921+ id="path1113"

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" />

925+ <path

926+ inkscape:export-ydpi="61.120499"

927+ inkscape:export-xdpi="61.120499"

928+ inkscape:connector-curvature="0"

929+ id="path1119"

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" />

933+ <text

934+ id="text950"

935+ y="104.70191"

936+ x="22.426785"

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"

942+ y="104.70191"

943+ x="22.426785"

944+ id="tspan948"

945+ sodipodi:role="line">module Core.Core</tspan></text>

946+ <rect

947+ inkscape:export-ydpi="61.120499"

948+ inkscape:export-xdpi="61.120499"

949+ y="100.20374"

950+ x="20.839275"

951+ height="9.7895899"

952+ width="47.889587"

953+ id="rect952"

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" />

955+ <text

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"

960+ x="22.955944"

961+ y="108.40608"

962+ id="text956"><tspan

963+ sodipodi:role="line"

964+ id="tspan954"

965+ x="22.955944"

966+ y="108.40608"

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>

968+ <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"

973+ x="79.312202"

974+ y="92.266502"

975+ id="text960"><tspan

976+ sodipodi:role="line"

977+ id="tspan958"

978+ x="79.312202"

979+ y="92.266502"

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>

981+ <rect

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"

983+ id="rect962"

984+ width="61.912495"

985+ height="18.785419"

986+ x="77.724693"

987+ y="87.768333"

988+ inkscape:export-xdpi="61.120499"

989+ inkscape:export-ydpi="61.120499" />

990+ <text

991+ id="text966"

992+ y="95.970665"

993+ x="79.841362"

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"

999+ y="95.970665"

1000+ x="79.841362"

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"

1004+ y="100.38039"

1005+ x="79.841362"

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"

1009+ y="104.79011"

1010+ x="79.841362"

1011+ sodipodi:role="line"

1012+ id="tspan972">Type erased, explicit case trees</tspan></text>

1013+ <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"

1018+ x="22.162193"

1019+ y="73.217979"

1020+ id="text978"><tspan

1021+ sodipodi:role="line"

1022+ id="tspan976"

1023+ x="22.162193"

1024+ y="73.217979"

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>

1026+ <rect

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"

1028+ id="rect980"

1029+ width="55.827087"

1030+ height="10.054173"

1031+ x="20.574694"

1032+ y="68.719742"

1033+ inkscape:export-xdpi="61.120499"

1034+ inkscape:export-ydpi="61.120499" />

1035+ <text

1036+ id="text984"

1037+ y="76.92215"

1038+ x="22.69136"

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"

1044+ y="76.92215"

1045+ x="22.69136"

1046+ id="tspan982"

1047+ sodipodi:role="line">command line options</tspan></text>

1048+ <text

1049+ id="text988"

1050+ y="89.886726"

1051+ x="22.162193"

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"

1057+ y="89.886726"

1058+ x="22.162193"

1059+ id="tspan986"

1060+ sodipodi:role="line">module Idris.Error</tspan></text>

1061+ <rect

1062+ inkscape:export-ydpi="61.120499"

1063+ inkscape:export-xdpi="61.120499"

1064+ y="85.388489"

1065+ x="20.574694"

1066+ height="9.5250101"

1067+ width="37.835419"

1068+ id="rect990"

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" />

1070+ <text

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"

1075+ x="22.69136"

1076+ y="93.590897"

1077+ id="text994"><tspan

1078+ sodipodi:role="line"

1079+ id="tspan992"

1080+ x="22.69136"

1081+ y="93.590897"

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>

1083+ <path

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"

1086+ id="path996"

1087+ inkscape:connector-curvature="0"

1088+ inkscape:export-xdpi="61.120499"

1089+ inkscape:export-ydpi="61.120499"

1090+ sodipodi:nodetypes="cc" />

1091+ <path

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"

1094+ id="path1201"

1095+ inkscape:connector-curvature="0"

1096+ sodipodi:nodetypes="cc"

1097+ inkscape:export-xdpi="61.120499"

1098+ inkscape:export-ydpi="61.120499" />

1099+ <path

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"

1102+ id="path1203"

1103+ inkscape:connector-curvature="0"

1104+ inkscape:export-xdpi="61.120499"

1105+ inkscape:export-ydpi="61.120499" />

1106+ <text

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;"

1109+ x="158.75"

1110+ y="226.09137"

1111+ id="text1473"

1112+ inkscape:export-xdpi="61.120499"

1113+ inkscape:export-ydpi="61.120499"><tspan

1114+ sodipodi:role="line"

1115+ id="tspan1471"

1116+ x="158.75"

1117+ y="226.09137"

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"

1120+ x="158.75"

1121+ y="230.92491"

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"

1125+ x="158.75"

1126+ y="235.75845"

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>

1129+ <path

1130+ inkscape:connector-curvature="0"

1131+ id="path957"

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" />

1136+ <text

1137+ inkscape:export-ydpi="61.120499"

1138+ inkscape:export-xdpi="61.120499"

1139+ id="text965"

1140+ y="177.14345"

1141+ x="176.74167"

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

1144+ id="tspan963"

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;"

1146+ y="177.14345"

1147+ x="176.74167"

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;"

1150+ y="181.97699"

1151+ x="176.74167"

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;"

1155+ y="186.81053"

1156+ x="176.74167"

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;"

1160+ y="191.64406"

1161+ x="176.74167"

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;"

1165+ y="196.4776"

1166+ x="176.74167"

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;"

1170+ y="201.31114"

1171+ x="176.74167"

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;"

1175+ y="206.14468"

1176+ x="176.74167"

1177+ sodipodi:role="line"

1178+ id="tspan993">like.</tspan></text>

1179+ <path

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"

1182+ id="path997"

1183+ inkscape:connector-curvature="0"

1184+ inkscape:export-xdpi="61.120499"

1185+ inkscape:export-ydpi="61.120499" />

1186+ <text

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"

1189+ x="176.21251"

1190+ y="115.76012"

1191+ id="text1013"

1192+ inkscape:export-xdpi="61.120499"

1193+ inkscape:export-ydpi="61.120499"><tspan

1194+ id="tspan1011"

1195+ sodipodi:role="line"

1196+ x="176.21251"

1197+ y="115.76012"

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"

1200+ x="176.21251"

1201+ y="120.59366"

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"

1205+ x="176.21251"

1206+ y="125.42719"

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"

1210+ x="176.21251"

1211+ y="130.26073"

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"

1215+ x="176.21251"

1216+ y="135.09427"

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>

1219+ <path

1220+ inkscape:connector-curvature="0"

1221+ id="path1058"

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" />

1227+ <text

1228+ inkscape:export-ydpi="61.120499"

1229+ inkscape:export-xdpi="61.120499"

1230+ id="text1070"

1231+ y="57.287201"

1232+ x="175.41876"

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;"

1236+ y="57.287201"

1237+ x="175.41876"

1238+ sodipodi:role="line"

1239+ id="tspan1060">Idris.Parser</tspan><tspan

1240+ id="tspan1068"

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;"

1242+ y="62.120739"

1243+ x="175.41876"

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;"

1246+ y="66.954277"

1247+ x="175.41876"

1248+ sodipodi:role="line"

1249+ id="tspan1089">command line.</tspan></text>

1250+ </g>

1251+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 210 297"

15+ version="1.1"

16+ id="svg8"

17+ inkscape:version="0.92.2 5c3e80d, 2017-08-06"

18+ sodipodi:docname="topLevel.svg">

19+ <defs

20+ id="defs2">

21+ <marker

22+ inkscape:isstock="true"

23+ style="overflow:visible;"

24+ id="marker3617"

25+ refX="0.0"

26+ refY="0.0"

27+ orient="auto"

28+ inkscape:stockid="Arrow1Mend">

29+ <path

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 "

33+ id="path3615" />

34+ </marker>

35+ <marker

36+ inkscape:stockid="Arrow1Mend"

37+ orient="auto"

38+ refY="0.0"

39+ refX="0.0"

40+ id="marker2891"

41+ style="overflow:visible;"

42+ inkscape:isstock="true"

43+ inkscape:collect="always">

44+ <path

45+ id="path2889"

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)" />

49+ </marker>

50+ <marker

51+ inkscape:stockid="Arrow1Mend"

52+ orient="auto"

53+ refY="0.0"

54+ refX="0.0"

55+ id="marker2049"

56+ style="overflow:visible;"

57+ inkscape:isstock="true">

58+ <path

59+ id="path2047"

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)" />

63+ </marker>

64+ <marker

65+ inkscape:isstock="true"

66+ style="overflow:visible;"

67+ id="marker1539"

68+ refX="0.0"

69+ refY="0.0"

70+ orient="auto"

71+ inkscape:stockid="Arrow1Mend"

72+ inkscape:collect="always">

73+ <path

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 "

77+ id="path1537" />

78+ </marker>

79+ <marker

80+ inkscape:stockid="Arrow1Mend"

81+ orient="auto"

82+ refY="0.0"

83+ refX="0.0"

84+ id="Arrow1Mend"

85+ style="overflow:visible;"

86+ inkscape:isstock="true"

87+ inkscape:collect="always">

88+ <path

89+ id="path830"

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)" />

93+ </marker>

94+ </defs>

95+ <sodipodi:namedview

96+ id="base"

97+ pagecolor="#ffffff"

98+ bordercolor="#666666"

99+ borderopacity="1.0"

100+ inkscape:pageopacity="0.0"

101+ inkscape:pageshadow="2"

102+ inkscape:zoom="1"

103+ inkscape:cx="396.85039"

104+ inkscape:cy="560"

105+ inkscape:document-units="mm"

106+ inkscape:current-layer="layer1"

107+ showgrid="false"

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" />

113+ <metadata

114+ id="metadata5">

115+ <rdf:RDF>

116+ <cc:Work

117+ rdf:about="">

118+ <dc:format>image/svg+xml</dc:format>

119+ <dc:type

120+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

121+ <dc:title />

122+ </cc:Work>

123+ </rdf:RDF>

124+ </metadata>

125+ <g

126+ inkscape:label="Layer 1"

127+ inkscape:groupmode="layer"

128+ id="layer1">

129+ <rect

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"

131+ id="rect815"

132+ width="35.983334"

133+ height="18.25625"

134+ x="37.306248"

135+ y="79.512497"

136+ inkscape:export-xdpi="61.120499"

137+ inkscape:export-ydpi="61.120499" />

138+ <rect

139+ y="79.512497"

140+ x="92.339577"

141+ height="18.25625"

142+ width="35.983334"

143+ id="rect817"

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" />

147+ <path

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"

150+ id="path819"

151+ inkscape:connector-curvature="0"

152+ inkscape:export-xdpi="61.120499"

153+ inkscape:export-ydpi="61.120499" />

154+ <path

155+ inkscape:connector-curvature="0"

156+ id="path1535"

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" />

161+ <path

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"

164+ id="path2045"

165+ inkscape:connector-curvature="0"

166+ inkscape:export-xdpi="61.120499"

167+ inkscape:export-ydpi="61.120499" />

168+ <text

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"

171+ x="20.372915"

172+ y="85.597931"

173+ id="text2857"

174+ inkscape:export-xdpi="61.120499"

175+ inkscape:export-ydpi="61.120499"><tspan

176+ sodipodi:role="line"

177+ id="tspan2855"

178+ x="20.372915"

179+ y="85.597931"

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>

181+ <text

182+ id="text2861"

183+ y="80.835434"

184+ x="76.199997"

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"

190+ y="80.835434"

191+ x="76.199997"

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"

195+ y="86.127098"

196+ x="76.199997"

197+ sodipodi:role="line"

198+ id="tspan2871">Token</tspan></text>

199+ <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"

202+ x="130.96875"

203+ y="85.068764"

204+ id="text2865"

205+ inkscape:export-xdpi="61.120499"

206+ inkscape:export-ydpi="61.120499"><tspan

207+ sodipodi:role="line"

208+ id="tspan2863"

209+ x="130.96875"

210+ y="85.068764"

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>

212+ <text

213+ id="text2875"

214+ y="89.302101"

215+ x="47.360416"

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;"

221+ y="89.302101"

222+ x="47.360416"

223+ id="tspan2873"

224+ sodipodi:role="line">Lexer</tspan></text>

225+ <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"

228+ x="100.27708"

229+ y="89.037521"

230+ id="text2879"

231+ inkscape:export-xdpi="61.120499"

232+ inkscape:export-ydpi="61.120499"><tspan

233+ sodipodi:role="line"

234+ id="tspan2877"

235+ x="100.27708"

236+ y="89.037521"

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>

238+ <path

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"

241+ id="path2887"

242+ inkscape:connector-curvature="0"

243+ sodipodi:nodetypes="cc"

244+ inkscape:export-xdpi="61.120499"

245+ inkscape:export-ydpi="61.120499" />

246+ <path

247+ sodipodi:nodetypes="cc"

248+ inkscape:connector-curvature="0"

249+ id="path3613"

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" />

254+ <text

255+ id="text4173"

256+ y="69.987518"

257+ x="43.391666"

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"

263+ y="69.987518"

264+ x="43.391666"

265+ id="tspan4171"

266+ sodipodi:role="line">Recogniser</tspan></text>

267+ <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"

270+ x="97.102081"

271+ y="69.722939"

272+ id="text4177"

273+ inkscape:export-xdpi="61.120499"

274+ inkscape:export-ydpi="61.120499"><tspan

275+ sodipodi:role="line"

276+ id="tspan4175"

277+ x="97.102081"

278+ y="69.722939"

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>

280+ <text

281+ inkscape:export-ydpi="61.120499"

282+ inkscape:export-xdpi="61.120499"

283+ id="text854"

284+ y="93.800011"

285+ x="131.23334"

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"

289+ y="103.5316"

290+ x="131.23334"

291+ id="tspan852"

292+ sodipodi:role="line" /></text>

293+ </g>

294+</svg>

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/) -->

3+

4+<svg

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"

12+ width="210mm"

13+ height="297mm"

14+ viewBox="0 0 744.09448819 1052.3622047"

15+ id="svg2"

16+ version="1.1"

17+ inkscape:version="0.91 r13725"

18+ sodipodi:docname="plusReducesProof.svg">

19+ <defs

20+ id="defs4">

21+ <marker

22+ inkscape:stockid="Arrow1Mend"

23+ orient="auto"

24+ refY="0.0"

25+ refX="0.0"

26+ id="marker6540"

27+ style="overflow:visible;"

28+ inkscape:isstock="true">

29+ <path

30+ id="path6542"

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)" />

34+ </marker>

35+ <marker

36+ inkscape:stockid="Arrow1Mend"

37+ orient="auto"

38+ refY="0.0"

39+ refX="0.0"

40+ id="marker5748"

41+ style="overflow:visible;"

42+ inkscape:isstock="true">

43+ <path

44+ id="path5750"

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)" />

48+ </marker>

49+ <marker

50+ inkscape:isstock="true"

51+ style="overflow:visible;"

52+ id="marker5154"

53+ refX="0.0"

54+ refY="0.0"

55+ orient="auto"

56+ inkscape:stockid="Arrow1Mend"

57+ inkscape:collect="always">

58+ <path

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 "

62+ id="path5156" />

63+ </marker>

64+ <marker

65+ inkscape:stockid="Arrow1Mend"

66+ orient="auto"

67+ refY="0.0"

68+ refX="0.0"

69+ id="Arrow1Mend"

70+ style="overflow:visible;"

71+ inkscape:isstock="true"

72+ inkscape:collect="always">

73+ <path

74+ id="path4189"

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)" />

78+ </marker>

79+ </defs>

80+ <sodipodi:namedview

81+ id="base"

82+ pagecolor="#ffffff"

83+ bordercolor="#666666"

84+ borderopacity="1.0"

85+ inkscape:pageopacity="0.0"

86+ inkscape:pageshadow="2"

87+ inkscape:zoom="1"

88+ inkscape:cx="397.18872"

89+ inkscape:cy="520"

90+ inkscape:document-units="px"

91+ inkscape:current-layer="layer1"

92+ showgrid="false"

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" />

98+ <metadata

99+ id="metadata7">

100+ <rdf:RDF>

101+ <cc:Work

102+ rdf:about="">

103+ <dc:format>image/svg+xml</dc:format>

104+ <dc:type

105+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />

106+ <dc:title></dc:title>

107+ </cc:Work>

108+ </rdf:RDF>

109+ </metadata>

110+ <g

111+ inkscape:label="Layer 1"

112+ inkscape:groupmode="layer"

113+ id="layer1">

114+ <text

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"

117+ x="266"

118+ y="225.36221"

119+ id="text4136"

120+ sodipodi:linespacing="125%"><tspan

121+ sodipodi:role="line"

122+ id="tspan4138"

123+ x="266"

124+ y="225.36221">assumptions</tspan><tspan

125+ sodipodi:role="line"

126+ x="266"

127+ y="250.36221"

128+ id="tspan4140">(context)</tspan></text>

129+ <text

130+ sodipodi:linespacing="125%"

131+ id="text4142"

132+ y="238.36221"

133+ x="526"

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

136+ id="tspan4146"

137+ y="238.36221"

138+ x="526"

139+ sodipodi:role="line">goal</tspan></text>

140+ <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"

143+ x="420"

144+ y="289.36221"

145+ id="text4150"

146+ sodipodi:linespacing="125%"><tspan

147+ sodipodi:role="line"

148+ x="420"

149+ y="289.36221"

150+ id="tspan4152">(k : Nat) -&gt; (k = plus k 0) -&gt; S k = S (plus k 0)</tspan></text>

151+ <path

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"

154+ id="path4154"

155+ inkscape:connector-curvature="0" />

156+ <path

157+ inkscape:connector-curvature="0"

158+ id="path4160"

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" />

161+ <text

162+ sodipodi:linespacing="125%"

163+ id="text4162"

164+ y="312.36221"

165+ x="175"

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

168+ id="tspan4164"

169+ y="312.36221"

170+ x="175"

171+ sodipodi:role="line">intro `{{k}}</tspan></text>

172+ <text

173+ sodipodi:linespacing="125%"

174+ id="text4166"

175+ y="333.36221"

176+ x="482"

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

179+ id="tspan4168"

180+ y="333.36221"

181+ x="482"

182+ sodipodi:role="line">(k = plus k 0) -&gt; S k = S (plus k 0)</tspan></text>

183+ <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"

186+ x="324"

187+ y="334.36221"

188+ id="text4170"

189+ sodipodi:linespacing="125%"><tspan

190+ sodipodi:role="line"

191+ x="324"

192+ y="334.36221"

193+ id="tspan4172">k : Nat</tspan></text>

194+ <path

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"

197+ id="path4174"

198+ inkscape:connector-curvature="0"

199+ sodipodi:nodetypes="cc" />

200+ <path

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"

203+ id="path5134"

204+ inkscape:connector-curvature="0" />

205+ <text

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"

208+ x="171"

209+ y="355.36221"

210+ id="text5136"

211+ sodipodi:linespacing="125%"><tspan

212+ sodipodi:role="line"

213+ x="171"

214+ y="355.36221"

215+ id="tspan5138">intro `{{ih}}</tspan></text>

216+ <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"

219+ x="570"

220+ y="372.36221"

221+ id="text5140"

222+ sodipodi:linespacing="125%"><tspan

223+ sodipodi:role="line"

224+ x="570"

225+ y="372.36221"

226+ id="tspan5142">S k = S (plus k 0)</tspan></text>

227+ <text

228+ sodipodi:linespacing="125%"

229+ id="text5144"

230+ y="378.36221"

231+ x="324"

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

234+ id="tspan5146"

235+ y="378.36221"

236+ x="324"

237+ sodipodi:role="line">k : Nat</tspan></text>

238+ <text

239+ sodipodi:linespacing="125%"

240+ id="text5150"

241+ y="393.36221"

242+ x="323"

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

245+ id="tspan5152"

246+ y="393.36221"

247+ x="323"

248+ sodipodi:role="line">ih : k = plus k 0</tspan></text>

249+ <path

250+ inkscape:connector-curvature="0"

251+ id="path5728"

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" />

254+ <text

255+ sodipodi:linespacing="125%"

256+ id="text5730"

257+ y="408.36221"

258+ x="109"

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

261+ id="tspan5732"

262+ y="408.36221"

263+ x="109"

264+ sodipodi:role="line">rewriteWith (Var `{{ih}})</tspan></text>

265+ <text

266+ sodipodi:linespacing="125%"

267+ id="text5734"

268+ y="424.36221"

269+ x="587"

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

272+ id="tspan5736"

273+ y="424.36221"

274+ x="587"

275+ sodipodi:role="line">S k = S k </tspan></text>

276+ <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"

279+ x="325"

280+ y="430.36221"

281+ id="text5738"

282+ sodipodi:linespacing="125%"><tspan

283+ sodipodi:role="line"

284+ x="325"

285+ y="430.36221"

286+ id="tspan5740">k : Nat</tspan></text>

287+ <path

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"

290+ id="path5742"

291+ inkscape:connector-curvature="0"

292+ sodipodi:nodetypes="cc" />

293+ <text

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"

296+ x="324"

297+ y="445.36221"

298+ id="text5744"

299+ sodipodi:linespacing="125%"><tspan

300+ sodipodi:role="line"

301+ x="324"

302+ y="445.36221"

303+ id="tspan5746">ih : k = plus k 0</tspan></text>

304+ <path

305+ inkscape:connector-curvature="0"

306+ id="path7294"

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" />

310+ <path

311+ sodipodi:nodetypes="cc"

312+ inkscape:connector-curvature="0"

313+ id="path5148"

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)" />

316+ <path

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"

319+ id="path6538"

320+ inkscape:connector-curvature="0"

321+ sodipodi:nodetypes="cc" />

322+ <path

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"

325+ id="path7308"

326+ inkscape:connector-curvature="0" />

327+ <text

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"

330+ x="177"

331+ y="462.36221"

332+ id="text7310"

333+ sodipodi:linespacing="125%"><tspan

334+ sodipodi:role="line"

335+ x="177"

336+ y="462.36221"

337+ id="tspan7312">reflexivity</tspan></text>

338+ </g>

339+</svg>

docs/image/recogniser.pngnew file

Binary file not shown.

docs/image/recogniser.svgnew file+477

This diff is too big to show here.

docs/image/solve.pngnew file

Binary file not shown.

docs/image/solve.svgnew file+163

This diff is too big to show here.

docs/image/tokenise.pngnew file

Binary file not shown.

docs/image/tokenise.svgnew file+740

This diff is too big to show here.

docs/image/tree.pngnew file

Binary file not shown.

docs/image/tree.svgnew file+212

This diff is too big to show here.

docs/index.rstnew file+30

This diff is too big to show here.

docs/listing/idris-prompt-helloworld.txtnew file+15

This diff is too big to show here.

docs/listing/idris-prompt-interp.txtnew file+12

This diff is too big to show here.

docs/listing/idris-prompt-start.txtnew file+8

This diff is too big to show here.

docs/make.batnew file+263

This diff is too big to show here.

docs/parserLibrary/index.rstnew file+24

This diff is too big to show here.

docs/parserLibrary/introduction.rstnew file+76

This diff is too big to show here.

docs/parserLibrary/lexer.rstnew file+288

This diff is too big to show here.

docs/parserLibrary/parser.rstnew file+700

This diff is too big to show here.

docs/parserLibrary/whitespace.rstnew file+250

This diff is too big to show here.

docs/proofs/definitional.rstnew file+235

This diff is too big to show here.

docs/proofs/index.rstnew file+28

This diff is too big to show here.

docs/proofs/inductive.rstnew file+101

This diff is too big to show here.

docs/proofs/interactive.rstnew file+296

This diff is too big to show here.

docs/proofs/interactiveOld.rstnew file+169

This diff is too big to show here.

docs/proofs/patterns.rstnew file+351

This diff is too big to show here.

docs/proofs/pluscomm.rstnew file+189

This diff is too big to show here.

docs/proofs/propositional.rstnew file+133

This diff is too big to show here.

docs/reference/codegen.rstnew file+147

This diff is too big to show here.

docs/reference/compilation.rstnew file+131

This diff is too big to show here.

docs/reference/documenting.rstnew file+142

This diff is too big to show here.

docs/reference/erasure.rstnew file+502

This diff is too big to show here.

docs/reference/ffi.rstnew file+534

This diff is too big to show here.

docs/reference/ide-protocol.rstnew file+213

This diff is too big to show here.

docs/reference/index.rstnew file+41

This diff is too big to show here.

docs/reference/internals.rstnew file+179

This diff is too big to show here.

docs/reference/language-extensions.rstnew file+41

This diff is too big to show here.

docs/reference/language-features.rstnew file+54

This diff is too big to show here.

docs/reference/misc.rstnew file+228

This diff is too big to show here.

docs/reference/packages.rstnew file+150

This diff is too big to show here.

docs/reference/partial-evaluation.rstnew file+305

This diff is too big to show here.

docs/reference/repl.rstnew file+546

This diff is too big to show here.

docs/reference/semantic-highlighting.rstnew file+50

This diff is too big to show here.

docs/reference/syntax-guide.rstnew file+489

This diff is too big to show here.

docs/reference/syntax-reference.rstnew file+422

This diff is too big to show here.

docs/reference/tactics.rstnew file+204

This diff is too big to show here.

docs/reference/type-directed-search.rstnew file+336

This diff is too big to show here.

docs/reference/uniqueness-types.rstnew file+252

This diff is too big to show here.

docs/st/composing.rstnew file+774

This diff is too big to show here.

docs/st/examples.rstnew file+439

This diff is too big to show here.

docs/st/index.rstnew file+27

This diff is too big to show here.

docs/st/introduction.rstnew file+93

This diff is too big to show here.

docs/st/machines.rstnew file+536

This diff is too big to show here.

docs/st/state.rstnew file+654

This diff is too big to show here.

docs/tutorial/conclusions.rstnew file+54

This diff is too big to show here.

docs/tutorial/index.rstnew file+37

This diff is too big to show here.

docs/tutorial/interactive.rstnew file+257

This diff is too big to show here.

docs/tutorial/interfaces.rstnew file+633

This diff is too big to show here.

docs/tutorial/interp.rstnew file+300

This diff is too big to show here.

docs/tutorial/introduction.rstnew file+74

This diff is too big to show here.

docs/tutorial/miscellany.rstnew file+589

This diff is too big to show here.

docs/tutorial/modules.rstnew file+274

This diff is too big to show here.

docs/tutorial/packages.rstnew file+185

This diff is too big to show here.

docs/tutorial/provisional.rstnew file+277

This diff is too big to show here.

docs/tutorial/starting.rstnew file+93

This diff is too big to show here.

docs/tutorial/syntax.rstnew file+211

This diff is too big to show here.

docs/tutorial/theorems.rstnew file+430

This diff is too big to show here.

docs/tutorial/typesfuns.rstnew file+1350

This diff is too big to show here.

docs/tutorial/views.rstnew file+156

This diff is too big to show here.

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.iconew 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.

idris-tutorial.pdfnew file

Binary file not shown.

idris.cabal+364−336

This diff is too big to show here.

idrisdoc/styles.cssnew file+320

This diff is too big to show here.

iif/adder.iifdeleted−30

This diff is too big to show here.

iif/big.iifdeleted−7

This diff is too big to show here.

iif/ctest.cdeleted−106

This diff is too big to show here.

iif/lazy.iifdeleted−21

This diff is too big to show here.

iif/testmap.iifdeleted−30

This diff is too big to show here.

iif/testvm.iifdeleted−32

This diff is too big to show here.

jsrts/Runtime-browser.jsdeleted−3

This diff is too big to show here.

jsrts/Runtime-common.js+21−50

This diff is too big to show here.

jsrts/Runtime-javascript.jsnew file+15

This diff is too big to show here.

jsrts/Runtime-node.js+40−6

This diff is too big to show here.

jsrts/jsbn/jsbn-browser.jsnew file+1353

This diff is too big to show here.

jsrts/jsbn/jsbn-node.jsnew file+1

This diff is too big to show here.

jsrts/jsbn/jsbn.jsdeleted−1235

This diff is too big to show here.

libs/Makefile+25−8

This diff is too big to show here.

libs/base/Control/Arrow.idr+70−10

This diff is too big to show here.

libs/base/Control/Catchable.idr+36−11

This diff is too big to show here.

libs/base/Control/Category.idr+8−6

This diff is too big to show here.

libs/base/Control/IOExcept.idr+20−24

This diff is too big to show here.

libs/base/Control/Isomorphism.idrnew file+319

This diff is too big to show here.

libs/base/Control/Monad/Identity.idr+29−7

This diff is too big to show here.

libs/base/Control/Monad/RWS.idr+50−41

This diff is too big to show here.

libs/base/Control/Monad/Reader.idr+24−13

This diff is too big to show here.

libs/base/Control/Monad/State.idr+50−22

This diff is too big to show here.

libs/base/Control/Monad/Trans.idrnew file+6

This diff is too big to show here.

libs/base/Control/Monad/Writer.idr+35−18

This diff is too big to show here.

libs/base/Data/Bits.idr+173−105

This diff is too big to show here.

libs/base/Data/BoundedList.idrdeleted−92

This diff is too big to show here.

libs/base/Data/Buffer.idrnew file+170

This diff is too big to show here.

libs/base/Data/Complex.idr+33−27

This diff is too big to show here.

libs/base/Data/Erased.idrnew file+29

This diff is too big to show here.

libs/base/Data/Fin.idrnew file+221

This diff is too big to show here.

libs/base/Data/Floats.idrdeleted−59

This diff is too big to show here.

libs/base/Data/HVect.idr+83−57

This diff is too big to show here.

libs/base/Data/IORef.idrnew file+61

This diff is too big to show here.

libs/base/Data/List.idrnew file+74

This diff is too big to show here.

libs/base/Data/List/Quantifiers.idrnew file+82

This diff is too big to show here.

libs/base/Data/List/Views.idrnew file+223

This diff is too big to show here.

libs/base/Data/Mod2.idr+15−17

This diff is too big to show here.

libs/base/Data/Morphisms.idr+54−26

This diff is too big to show here.

libs/base/Data/Nat/Views.idrnew file+34

This diff is too big to show here.

libs/base/Data/Primitives/Views.idrnew file+81

This diff is too big to show here.

libs/base/Data/Sign.idrdeleted−6

This diff is too big to show here.

libs/base/Data/So.idrnew file+36

This diff is too big to show here.

libs/base/Data/SortedSet.idrdeleted−25

This diff is too big to show here.

libs/base/Data/String.idrnew file+114

This diff is too big to show here.

libs/base/Data/String/Views.idrnew file+15

This diff is too big to show here.

libs/base/Data/Vect.idr+1031−8

This diff is too big to show here.

libs/base/Data/Vect/Quantifiers.idr+37−7

This diff is too big to show here.

libs/base/Data/Vect/Views.idrnew file+83

This diff is too big to show here.

libs/base/Data/ZZ.idrdeleted−144

This diff is too big to show here.

libs/base/Debug/Error.idrnew file+17

This diff is too big to show here.

libs/base/Debug/Trace.idr+6−2

This diff is too big to show here.

libs/base/Decidable/Decidable.idrdeleted−24

This diff is too big to show here.

libs/base/Decidable/Order.idrdeleted−87

This diff is too big to show here.

libs/base/Language/Reflection.idrdeleted−186

This diff is too big to show here.

libs/base/Language/Reflection/Utils.idr+329−123

This diff is too big to show here.

libs/base/Makefile+17−9

This diff is too big to show here.

libs/base/Providers.idrdeleted−5

This diff is too big to show here.

libs/base/Syntax/PreorderReasoning.idrnew file+17

This diff is too big to show here.

libs/base/System.idr+73−34

This diff is too big to show here.

libs/base/System/Concurrency/Channels.idrnew file+70

This diff is too big to show here.

libs/base/System/Concurrency/Process.idrdeleted−68

This diff is too big to show here.

libs/base/System/Concurrency/Raw.idr+100−14

This diff is too big to show here.

libs/base/System/Info.idrnew file+16

This diff is too big to show here.

libs/base/Uninhabited.idrdeleted−12

This diff is too big to show here.

libs/base/base.ipkg+51−28

This diff is too big to show here.

libs/contrib/CFFI.idrnew file+4

This diff is too big to show here.

libs/contrib/CFFI/Memory.idrnew file+99

This diff is too big to show here.

libs/contrib/CFFI/Types.idrnew file+161

This diff is too big to show here.

libs/contrib/Control/Algebra.idrnew file+147

This diff is too big to show here.

libs/contrib/Control/Algebra/Lattice.idrnew file+140

This diff is too big to show here.

libs/contrib/Control/Algebra/Laws.idrnew file+153

This diff is too big to show here.

libs/contrib/Control/Algebra/NumericImplementations.idrnew file+134

This diff is too big to show here.

libs/contrib/Control/Algebra/VectorSpace.idrnew file+32

This diff is too big to show here.

libs/contrib/Control/Delayed.idrnew file+26

This diff is too big to show here.

libs/contrib/Control/Isomorphism/Extra.idrnew file+42

This diff is too big to show here.

libs/contrib/Control/Isomorphism/Fin.idrnew file+54

This diff is too big to show here.

libs/contrib/Control/Isomorphism/Primitives.idrnew file+35

This diff is too big to show here.

libs/contrib/Control/Isomorphism/Vect.idrnew file+155

This diff is too big to show here.

libs/contrib/Control/Monad/Syntax.idrnew file+18

This diff is too big to show here.

libs/contrib/Control/Partial.idrnew file+14

This diff is too big to show here.

libs/contrib/Control/Pipeline.idrnew file+26

This diff is too big to show here.

libs/contrib/Control/ST.idrnew file+660

This diff is too big to show here.

libs/contrib/Control/ST/Exception.idrnew file+38

This diff is too big to show here.

libs/contrib/Control/ST/File.idrnew file+247

This diff is too big to show here.

libs/contrib/Control/ST/ImplicitCall.idrnew file+13

This diff is too big to show here.

libs/contrib/Control/ST/Random.idrnew file+42

This diff is too big to show here.

libs/contrib/Data/Bool/Extra.idrnew file+82

This diff is too big to show here.

libs/contrib/Data/BoundedList.idrnew file+125

This diff is too big to show here.

libs/contrib/Data/Chain.idrnew file+46

This diff is too big to show here.

libs/contrib/Data/CoList.idrnew file+54

This diff is too big to show here.

libs/contrib/Data/Combinators.idrnew file+38

This diff is too big to show here.

libs/contrib/Data/Combinators/Applicative.idrnew file+27

This diff is too big to show here.

libs/contrib/Data/Combinators/Arrow.idrnew file+15

This diff is too big to show here.

libs/contrib/Data/Fin/Extra.idrnew file+86

This diff is too big to show here.

libs/contrib/Data/Fuel.idrnew file+18

This diff is too big to show here.

libs/contrib/Data/Fun.idrnew file+18

This diff is too big to show here.

libs/contrib/Data/Graph.idrnew file+8

This diff is too big to show here.

libs/contrib/Data/Hash.idrnew file+87

This diff is too big to show here.

libs/base/Data/Heap.idr → libs/contrib/Data/Heap.idrrenamed+31−47

This diff is too big to show here.

libs/contrib/Data/IOArray.idrnew file+47

This diff is too big to show here.

libs/contrib/Data/List/Group.idrnew file+27

This diff is too big to show here.

libs/contrib/Data/List/Permutations.idrnew file+12

This diff is too big to show here.

libs/contrib/Data/List/Reverse.idrnew file+99

This diff is too big to show here.

libs/contrib/Data/List/Zipper.idrnew file+160

This diff is too big to show here.

libs/contrib/Data/Logic/Propositional.idrnew file+161

This diff is too big to show here.

libs/contrib/Data/Matrix.idrnew file+59

This diff is too big to show here.

libs/contrib/Data/Matrix/Algebraic.idrnew file+149

This diff is too big to show here.

libs/contrib/Data/Matrix/Numeric.idrnew file+135

This diff is too big to show here.

libs/contrib/Data/Monoid.idrnew file+33

This diff is too big to show here.

libs/contrib/Data/Nat.idrnew file+25

This diff is too big to show here.

libs/contrib/Data/Nat/Ack.idrnew file+60

This diff is too big to show here.

libs/contrib/Data/Nat/DivMod.idrnew file+61

This diff is too big to show here.

libs/contrib/Data/Nat/DivMod/IteratedSubtraction.idrnew file+165

This diff is too big to show here.

libs/contrib/Data/Nat/Fact.idrnew file+56

This diff is too big to show here.

libs/contrib/Data/Nat/Fib.idrnew file+50

This diff is too big to show here.

libs/contrib/Data/Nat/Parity.idrnew file+217

This diff is too big to show here.

libs/contrib/Data/Pairs/Implicit.idrnew file+13

This diff is too big to show here.

libs/contrib/Data/Polyhedra.idrnew file+9

This diff is too big to show here.

libs/contrib/Data/PosNat.idrnew file+57

This diff is too big to show here.

libs/contrib/Data/Rel.idrnew file+13

This diff is too big to show here.

libs/contrib/Data/Sign.idrnew file+39

This diff is too big to show here.

libs/contrib/Data/SortedBag.idrnew file+127

This diff is too big to show here.

libs/base/Data/SortedMap.idr → libs/contrib/Data/SortedMap.idrrenamed+136−60

This diff is too big to show here.

libs/contrib/Data/SortedSet.idrnew file+66

This diff is too big to show here.

libs/contrib/Data/Storable.idrnew file+41

This diff is too big to show here.

libs/contrib/Data/Stream/Extra.idrnew file+10

This diff is too big to show here.

libs/contrib/Data/String/Extra.idrnew file+88

This diff is too big to show here.

libs/contrib/Data/ZZ.idrnew file+355

This diff is too big to show here.

libs/contrib/Decidable/Decidable.idrnew file+23

This diff is too big to show here.

libs/contrib/Decidable/Order.idrnew file+156

This diff is too big to show here.

libs/contrib/Interfaces/Correlative.idrnew file+63

This diff is too big to show here.

libs/contrib/Interfaces/Proposition.idrnew file+32

This diff is too big to show here.

libs/contrib/Interfaces/Verified.idrnew file+359

This diff is too big to show here.

libs/contrib/Language/JSON.idrnew file+14

This diff is too big to show here.

libs/contrib/Language/JSON/Data.idrnew file+98

This diff is too big to show here.

libs/contrib/Language/JSON/Lexer.idrnew file+40

This diff is too big to show here.

libs/contrib/Language/JSON/Parser.idrnew file+71

This diff is too big to show here.

libs/contrib/Language/JSON/String.idrnew file+16

This diff is too big to show here.

libs/contrib/Language/JSON/String/Lexer.idrnew file+38

This diff is too big to show here.

libs/contrib/Language/JSON/String/Parser.idrnew file+25

This diff is too big to show here.

libs/contrib/Language/JSON/String/Tokens.idrnew file+60

This diff is too big to show here.

libs/contrib/Language/JSON/Tokens.idrnew file+72

This diff is too big to show here.

libs/contrib/Makefilenew file+25

This diff is too big to show here.

libs/base/Network/Cgi.idr → libs/contrib/Network/Cgi.idrrenamed+42−39

This diff is too big to show here.

libs/contrib/Network/Socket.idrnew file+246

This diff is too big to show here.

libs/contrib/Network/Socket/Data.idrnew file+172

This diff is too big to show here.

libs/contrib/Network/Socket/Raw.idrnew file+199

This diff is too big to show here.

libs/contrib/System/Concurrency/Process.idrnew file+86

This diff is too big to show here.

libs/contrib/Test/Unit.idrnew file+14

This diff is too big to show here.

libs/contrib/Test/Unit/Assertions.idrnew file+37

This diff is too big to show here.

libs/contrib/Test/Unit/Display.idrnew file+27

This diff is too big to show here.

libs/contrib/Test/Unit/Generic.idrnew file+43

This diff is too big to show here.

libs/contrib/Test/Unit/Runners.idrnew file+36

This diff is too big to show here.

libs/contrib/Text/Lexer.idrnew file+324

This diff is too big to show here.

libs/contrib/Text/Lexer/Core.idrnew file+193

This diff is too big to show here.

libs/contrib/Text/Literate.idrnew file+155

This diff is too big to show here.

libs/contrib/Text/Parser.idrnew file+226

This diff is too big to show here.

libs/contrib/Text/Parser/Core.idrnew file+265

This diff is too big to show here.

libs/contrib/Text/PrettyPrint/WL.idrnew file+18

This diff is too big to show here.

libs/contrib/Text/PrettyPrint/WL/Characters.idrnew file+103

This diff is too big to show here.

libs/contrib/Text/PrettyPrint/WL/Combinators.idrnew file+259

This diff is too big to show here.

libs/contrib/Text/PrettyPrint/WL/Core.idrnew file+226

This diff is too big to show here.

libs/contrib/Text/Quantity.idrnew file+38

This diff is too big to show here.

libs/contrib/Text/Token.idrnew file+38

This diff is too big to show here.

libs/contrib/contrib.ipkgnew file+113

This diff is too big to show here.

libs/effects/Effect/Default.idrnew file+47

This diff is too big to show here.

libs/effects/Effect/Exception.idr+16−24

This diff is too big to show here.

libs/effects/Effect/File.idr+408−49

This diff is too big to show here.

libs/effects/Effect/Logging/Category.idrnew file+181

This diff is too big to show here.

libs/effects/Effect/Logging/Default.idrnew file+118

This diff is too big to show here.

libs/effects/Effect/Logging/Level.idrnew file+81

This diff is too big to show here.

libs/effects/Effect/Memory.idr+76−61

This diff is too big to show here.

libs/effects/Effect/Monad.idrnew file+30

This diff is too big to show here.

libs/effects/Effect/Perf.idrnew file+230

This diff is too big to show here.

libs/effects/Effect/Random.idr+55−14

This diff is too big to show here.

libs/effects/Effect/Select.idr+9−7

This diff is too big to show here.

libs/effects/Effect/State.idr+16−16

This diff is too big to show here.

libs/effects/Effect/StdIO.idr+53−40

This diff is too big to show here.

libs/effects/Effect/System.idrnew file+52

This diff is too big to show here.

libs/effects/Effect/Trans.idrnew file+20

This diff is too big to show here.

libs/effects/Effects.idr+422−244

This diff is too big to show here.

libs/effects/Makefile+15−7

This diff is too big to show here.

libs/effects/effects.ipkg+20−5

This diff is too big to show here.

libs/javascript/JavaScript.idrdeleted−104

This diff is too big to show here.

libs/javascript/JavaScript/JSON.idrdeleted−46

This diff is too big to show here.

libs/javascript/Makefiledeleted−14

This diff is too big to show here.

libs/javascript/javascript.ipkgdeleted−5

This diff is too big to show here.

libs/prelude/Builtins.idr+217−27

This diff is too big to show here.

libs/prelude/Decidable/Equality.idr+149−87

This diff is too big to show here.

libs/prelude/IO.idr+354−127

This diff is too big to show here.

libs/prelude/Language/Reflection.idrnew file+1287

This diff is too big to show here.

libs/prelude/Language/Reflection/Elab.idrnew file+775

This diff is too big to show here.

libs/base/Language/Reflection/Errors.idr → libs/prelude/Language/Reflection/Errors.idrrenamed+23−12

This diff is too big to show here.

libs/prelude/Makefile+17−9

This diff is too big to show here.

libs/prelude/Prelude.idr+213−422

This diff is too big to show here.

libs/prelude/Prelude/Algebra.idr+21−247

This diff is too big to show here.

libs/prelude/Prelude/Applicative.idr+56−16

This diff is too big to show here.

libs/prelude/Prelude/Basics.idr+34−22

This diff is too big to show here.

libs/prelude/Prelude/Bits.idr+106−49

This diff is too big to show here.

libs/prelude/Prelude/Bool.idr+29−17

This diff is too big to show here.

libs/prelude/Prelude/Cast.idr+28−18

This diff is too big to show here.

libs/prelude/Prelude/Chars.idr+48−3

This diff is too big to show here.

libs/prelude/Prelude/Classes.idrdeleted−250

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+56−14

This diff is too big to show here.

libs/prelude/Prelude/File.idrnew file+391

This diff is too big to show here.

libs/prelude/Prelude/Fin.idrdeleted−68

This diff is too big to show here.

libs/prelude/Prelude/Foldable.idr+50−13

This diff is too big to show here.

libs/prelude/Prelude/Functor.idr+29−2

This diff is too big to show here.

libs/prelude/Prelude/Interactive.idrnew file+180

This diff is too big to show here.

libs/prelude/Prelude/Interfaces.idrnew file+416

This diff is too big to show here.

libs/prelude/Prelude/List.idr+572−207

This diff is too big to show here.

libs/prelude/Prelude/Maybe.idr+73−23

This diff is too big to show here.

libs/prelude/Prelude/Monad.idr+42−11

This diff is too big to show here.

libs/prelude/Prelude/Nat.idr+462−529

This diff is too big to show here.

libs/prelude/Prelude/Pairs.idrnew file+45

This diff is too big to show here.

libs/prelude/Prelude/Providers.idrnew file+33

This diff is too big to show here.

libs/prelude/Prelude/Show.idrnew file+196

This diff is too big to show here.

libs/prelude/Prelude/Stream.idr+78−12

This diff is too big to show here.

libs/prelude/Prelude/Strings.idr+315−57

This diff is too big to show here.

libs/prelude/Prelude/Traversable.idr+23−3

This diff is too big to show here.

libs/prelude/Prelude/Uninhabited.idrnew file+24

This diff is too big to show here.

libs/prelude/Prelude/Vect.idrdeleted−325

This diff is too big to show here.

libs/prelude/Prelude/WellFounded.idrnew file+135

This diff is too big to show here.

libs/prelude/prelude.ipkg+37−8

This diff is too big to show here.

libs/pruviloj/Makefilenew file+22

This diff is too big to show here.

libs/pruviloj/Pruviloj.idrnew file+8

This diff is too big to show here.

libs/pruviloj/Pruviloj/Core.idrnew file+331

This diff is too big to show here.

libs/pruviloj/Pruviloj/Derive/DecEq.idrnew file+196

This diff is too big to show here.

libs/pruviloj/Pruviloj/Derive/Eliminators.idrnew file+265

This diff is too big to show here.

libs/pruviloj/Pruviloj/Disjoint.idrnew file+125

This diff is too big to show here.

libs/pruviloj/Pruviloj/Induction.idrnew file+159

This diff is too big to show here.

libs/pruviloj/Pruviloj/Injective.idrnew file+122

This diff is too big to show here.

libs/pruviloj/Pruviloj/Internals.idrnew file+136

This diff is too big to show here.

libs/pruviloj/Pruviloj/Internals/TyConInfo.idrnew file+108

This diff is too big to show here.

libs/pruviloj/Pruviloj/Renamers.idrnew file+44

This diff is too big to show here.

libs/pruviloj/README.txtnew file+45

This diff is too big to show here.

libs/pruviloj/pruviloj.ipkgnew file+19

This diff is too big to show here.

llvm/Makefiledeleted−24

This diff is too big to show here.

llvm/defs.cdeleted−182

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.

main/Main.hsnew file+81

This diff is too big to show here.

man/idris.1new file+127

This diff is too big to show here.

mkpkg.shnew file+67

This diff is too big to show here.

papers/impl-paper/Makefiledeleted−43

This diff is too big to show here.

papers/impl-paper/acmtrans.bstdeleted−1770

This diff is too big to show here.

papers/impl-paper/acmtrans2m.clsdeleted−1460

This diff is too big to show here.

papers/impl-paper/comments.stydeleted−29

This diff is too big to show here.

papers/impl-paper/compiling.texdeleted−2

This diff is too big to show here.

papers/impl-paper/conclusions.texdeleted−167

This diff is too big to show here.

papers/impl-paper/delab.texdeleted−159

This diff is too big to show here.

papers/impl-paper/elaboration.texdeleted−1956

This diff is too big to show here.

papers/impl-paper/hll.texdeleted−441

This diff is too big to show here.

papers/impl-paper/impldtp.texdeleted−159

This diff is too big to show here.

papers/impl-paper/intro.texdeleted−196

This diff is too big to show here.

papers/impl-paper/jfp.bstdeleted−1316

This diff is too big to show here.

papers/impl-paper/jfp1.clsdeleted−1894

This diff is too big to show here.

papers/impl-paper/library.bibdeleted−2295

This diff is too big to show here.

papers/impl-paper/library.ltxdeleted−325

This diff is too big to show here.

papers/impl-paper/literature.bibdeleted−3846

This diff is too big to show here.

papers/impl-paper/macros.ltxdeleted−1066

This diff is too big to show here.

papers/impl-paper/overview.texdeleted−35

This diff is too big to show here.

papers/impl-paper/proofstate.texdeleted−7

This diff is too big to show here.

papers/impl-paper/syntax.texdeleted−10

This diff is too big to show here.

papers/impl-paper/typechecking.texdeleted−718

This diff is too big to show here.

rts/Makefile+26−12

This diff is too big to show here.

rts/arduino/idris_main.cnew file+29

This diff is too big to show here.

rts/getline.cnew file+82

This diff is too big to show here.

rts/getline.hnew file+7

This diff is too big to show here.

rts/idris_bitstring.c+284−387

This diff is too big to show here.

rts/idris_bitstring.h+10−5

This diff is too big to show here.

rts/idris_buffer.cnew file+146

This diff is too big to show here.

rts/idris_buffer.hnew file+29

This diff is too big to show here.

rts/idris_gc.c+95−74

This diff is too big to show here.

rts/idris_gmp.c+169−135

This diff is too big to show here.

rts/idris_gmp.h+18−1

This diff is too big to show here.

rts/idris_heap.c+143−26

This diff is too big to show here.

rts/idris_heap.h+86−4

This diff is too big to show here.

rts/idris_main.c+50−5

This diff is too big to show here.

rts/idris_net.cnew file+351

This diff is too big to show here.

rts/idris_net.hnew file+91

This diff is too big to show here.

rts/idris_opts.c+1−1

This diff is too big to show here.

rts/idris_opts.h+1−1

This diff is too big to show here.

rts/idris_rts.c+802−321

This diff is too big to show here.

rts/idris_rts.h+380−109

This diff is too big to show here.

rts/idris_stats.c+11−11

This diff is too big to show here.

rts/idris_stats.h+13−10

This diff is too big to show here.

rts/idris_stdfgn.c+266−9

This diff is too big to show here.

rts/idris_stdfgn.h+46−1

This diff is too big to show here.

rts/idris_utf8.cnew file+180

This diff is too big to show here.

rts/idris_utf8.hnew file+26

This diff is too big to show here.

rts/mini-gmp.c+459−167

This diff is too big to show here.

rts/mini-gmp.h+47−8

This diff is too big to show here.

rts/seL4/CMakeLists.txtnew file+43

This diff is too big to show here.

rts/seL4/README.mdnew file+5

This diff is too big to show here.

rts/seL4/idris_main.cnew file+31

This diff is too big to show here.

rts/windows/win_utils.cnew file+67

This diff is too big to show here.

rts/windows/win_utils.hnew file+9

This diff is too big to show here.

samples/ST/Composite.idrnew file+8

This diff is too big to show here.

samples/ST/Graphics/Draw.idrnew file+88

This diff is too big to show here.

samples/ST/Graphics/Turtle.idrnew file+116

This diff is too big to show here.

samples/ST/Intro.idrnew file+75

This diff is too big to show here.

samples/ST/Login.idrnew file+55

This diff is too big to show here.

samples/ST/LoginCount.idrnew file+77

This diff is too big to show here.

samples/ST/Net/EchoSimple.idrnew file+24

This diff is too big to show here.

samples/ST/Net/Network.idrnew file+106

This diff is too big to show here.

samples/ST/Net/RandServer.idrnew file+156

This diff is too big to show here.

samples/ST/Net/Threads.idrnew file+23

This diff is too big to show here.

samples/ST/TreeTag.idrnew file+29

This diff is too big to show here.

samples/effects/ConsoleIO.idrnew file+15

This diff is too big to show here.

samples/effects/Exception.idrnew file+21

This diff is too big to show here.

samples/effects/Makefilenew file+8

This diff is too big to show here.

samples/effects/Random.idrnew file+37

This diff is too big to show here.

samples/effects/ReadInt.idrnew file+22

This diff is too big to show here.

samples/effects/Select.idrnew file+17

This diff is too big to show here.

samples/effects/TreeTag-noeff.idrnew file+21

This diff is too big to show here.

samples/effects/TreeTag.idrnew file+40

This diff is too big to show here.

samples/effects/TreeTagCount.idrnew file+29

This diff is too big to show here.

samples/effects/hworld.idrnew file+10

This diff is too big to show here.

samples/effects/vadd.idrnew file+41

This diff is too big to show here.

samples/misc/Makefilenew file+8

This diff is too big to show here.

samples/binary.idr → samples/misc/binary.idrrenamed+3−4

This diff is too big to show here.

samples/interp-alt.idr → samples/misc/interp-alt.idrrenamed+15−15

This diff is too big to show here.

samples/interp.idr → samples/misc/interp.idrrenamed+26−18

This diff is too big to show here.

samples/javaffi.idr → samples/misc/javaffi.idrrenamed+1−1

This diff is too big to show here.

samples/named_instance.lidr → samples/misc/named_implementation.lidrrenamed+5−5

This diff is too big to show here.

samples/reflection.idr → samples/misc/reflection.idrrenamed+27−27

This diff is too big to show here.

tutorial/examples/bmain.idr → samples/tutorial/BMain.idrrenamed+2−2

This diff is too big to show here.

tutorial/examples/btree.idr → samples/tutorial/BTree.idrrenamed+4

This diff is too big to show here.

samples/tutorial/BTreeMod.idrnew file+20

This diff is too big to show here.

tutorial/examples/foo.idr → samples/tutorial/Foo.idrrenamed

The content is the same.

tutorial/examples/hello.idr → samples/tutorial/Hello.idrrenamed

The content is the same.

samples/tutorial/Idiom.idrnew file+38

This diff is too big to show here.

tutorial/examples/classes.idr → samples/tutorial/Interfaces.idrrenamed+1−1

This diff is too big to show here.

tutorial/examples/interp.idr → samples/tutorial/Interp.idrrenamed+18−18

This diff is too big to show here.

tutorial/examples/letbind.idr → samples/tutorial/LetBind.idrrenamed+1−1

This diff is too big to show here.

tutorial/examples/Makefile → samples/tutorial/Makefilerenamed+4−1

This diff is too big to show here.

tutorial/examples/prims.idr → samples/tutorial/Prims.idrrenamed+1−1

This diff is too big to show here.

samples/tutorial/Record.idrnew file+21

This diff is too big to show here.

samples/tutorial/Theorems.idrnew file+37

This diff is too big to show here.

tutorial/examples/universe.idr → samples/tutorial/Universe.idrrenamed

The content is the same.

tutorial/examples/usefultypes.idr → samples/tutorial/UsefulTypes.idrrenamed+1

This diff is too big to show here.

samples/tutorial/VBroken.idrnew file+10

This diff is too big to show here.

samples/tutorial/Views.idrnew file+25

This diff is too big to show here.

samples/tutorial/ViewsBroken.idrnew file+12

This diff is too big to show here.

samples/tutorial/Wheres.idrnew file+14

This diff is too big to show here.

scripts/generate-multi-ghc-travis-templatenew file+20

This diff is too big to show here.

scripts/runidrisnew file+25

This diff is too big to show here.

scripts/runidris-nodenew file+25

This diff is too big to show here.

src/Core/CaseTree.hsdeleted−566

This diff is too big to show here.

src/Core/Constraints.hsdeleted−67

This diff is too big to show here.

src/Core/Elaborate.hsdeleted−661

This diff is too big to show here.

src/Core/Evaluate.hsdeleted−905

This diff is too big to show here.

src/Core/Execute.hsdeleted−540

This diff is too big to show here.

src/Core/ProofState.hsdeleted−832

This diff is too big to show here.

src/Core/TT.hsdeleted−1053

This diff is too big to show here.

src/Core/Typecheck.hsdeleted−241

This diff is too big to show here.

src/Core/Unify.hsdeleted−526

This diff is too big to show here.

src/IRTS/BCImp.hsdeleted−19

This diff is too big to show here.

src/IRTS/Bytecode.hs+103−40

This diff is too big to show here.

src/IRTS/CodegenC.hs+617−158

This diff is too big to show here.

src/IRTS/CodegenCommon.hs+39−8

This diff is too big to show here.

src/IRTS/CodegenJava.hsdeleted−753

This diff is too big to show here.

src/IRTS/CodegenJavaScript.hs+70−1126

This diff is too big to show here.

src/IRTS/CodegenLLVM.hsdeleted−1313

This diff is too big to show here.

src/IRTS/Compiler.hs+751−363

This diff is too big to show here.

src/IRTS/Defunctionalise.hs+150−142

This diff is too big to show here.

src/IRTS/DumpBC.hs+16−7

This diff is too big to show here.

src/IRTS/Exports.hsnew file+114

This diff is too big to show here.

src/IRTS/Inliner.hs+8−3

This diff is too big to show here.

src/IRTS/Java/ASTBuilding.hsdeleted−141

This diff is too big to show here.

src/IRTS/Java/JTypes.hsdeleted−299

This diff is too big to show here.

src/IRTS/Java/Mangling.hsdeleted−113

This diff is too big to show here.

src/IRTS/Java/Pom.hsdeleted−89

This diff is too big to show here.

src/IRTS/JavaScript/AST.hsnew file+285

This diff is too big to show here.

src/IRTS/JavaScript/Codegen.hsnew file+636

This diff is too big to show here.

src/IRTS/JavaScript/LangTransforms.hsnew file+99

This diff is too big to show here.

src/IRTS/JavaScript/Name.hsnew file+57

This diff is too big to show here.

src/IRTS/JavaScript/PrimOp.hsnew file+246

This diff is too big to show here.

src/IRTS/JavaScript/Specialize.hsnew file+109

This diff is too big to show here.

src/IRTS/Lang.hs+353−106

This diff is too big to show here.

src/IRTS/LangOpts.hsnew file+327

This diff is too big to show here.

src/IRTS/Portable.hsnew file+363

This diff is too big to show here.

src/IRTS/Simplified.hs+112−107

This diff is too big to show here.

src/IRTS/System.hsnew file+113

This diff is too big to show here.

src/Idris/ASTUtils.hsnew file+166

This diff is too big to show here.

src/Idris/AbsSyntax.hs+1781−710

This diff is too big to show here.

src/Idris/AbsSyntaxTree.hs+2140−1059

This diff is too big to show here.

src/Idris/Apropos.hsnew file+106

This diff is too big to show here.

src/Idris/CaseSplit.hs+353−175

This diff is too big to show here.

src/Idris/Chaser.hs+204−92

This diff is too big to show here.

src/Idris/CmdOptions.hsnew file+305

This diff is too big to show here.

src/Idris/Colours.hs+66−22

This diff is too big to show here.

src/Idris/Completion.hs+123−87

This diff is too big to show here.

src/Idris/Core/Binary.hsnew file+368

This diff is too big to show here.

src/Idris/Core/CaseTree.hsnew file+867

This diff is too big to show here.

src/Idris/Core/Constraints.hsnew file+256

This diff is too big to show here.

src/Idris/Core/DeepSeq.hsnew file+65

This diff is too big to show here.

src/Idris/Core/Elaborate.hsnew file+998

This diff is too big to show here.

src/Idris/Core/Evaluate.hsnew file+1268

This diff is too big to show here.

src/Idris/Core/Execute.hsnew file+739

This diff is too big to show here.

src/Idris/Core/ProofState.hsnew file+1073

This diff is too big to show here.

src/Idris/Core/ProofTerm.hsnew file+363

This diff is too big to show here.

src/Idris/Core/TT.hsnew file+1901

This diff is too big to show here.

src/Idris/Core/Typecheck.hsnew file+379

This diff is too big to show here.

src/Idris/Core/Unify.hsnew file+715

This diff is too big to show here.

src/Idris/Core/WHNF.hsnew file+256

This diff is too big to show here.

src/Idris/Coverage.hs+460−669

This diff is too big to show here.

src/Idris/DSL.hs+145−83

This diff is too big to show here.

src/Idris/DataOpts.hs+69−259

This diff is too big to show here.

src/Idris/DeepSeq.hs+95−383

This diff is too big to show here.

src/Idris/Delaborate.hs+710−164

This diff is too big to show here.

src/Idris/Directives.hsnew file+130

This diff is too big to show here.

src/Idris/Docs.hs+401−87

This diff is too big to show here.

src/Idris/Docstrings.hsnew file+301

This diff is too big to show here.

src/Idris/Elab/AsPat.hsnew file+73

This diff is too big to show here.

src/Idris/Elab/Clause.hsnew file+1251

This diff is too big to show here.

src/Idris/Elab/Data.hsnew file+313

This diff is too big to show here.

src/Idris/Elab/Implementation.hsnew file+489

This diff is too big to show here.

src/Idris/Elab/Interface.hsnew file+449

This diff is too big to show here.

src/Idris/Elab/Provider.hsnew file+99

This diff is too big to show here.

src/Idris/Elab/Quasiquote.hsnew file+180

This diff is too big to show here.

src/Idris/Elab/Record.hsnew file+446

This diff is too big to show here.

src/Idris/Elab/Rewrite.hsnew file+259

This diff is too big to show here.

src/Idris/Elab/RunElab.hsnew file+53

This diff is too big to show here.

src/Idris/Elab/Term.hsnew file+2788

This diff is too big to show here.

src/Idris/Elab/Transform.hsnew file+100

This diff is too big to show here.

src/Idris/Elab/Type.hsnew file+257

This diff is too big to show here.

src/Idris/Elab/Utils.hsnew file+824

This diff is too big to show here.

src/Idris/Elab/Value.hsnew file+124

This diff is too big to show here.

src/Idris/ElabDecls.hs+194−1638

This diff is too big to show here.

src/Idris/ElabTerm.hsdeleted−1340

This diff is too big to show here.

src/Idris/Erasure.hsnew file+634

This diff is too big to show here.

src/Idris/ErrReverse.hsnew file+73

This diff is too big to show here.

src/Idris/Error.hs+120−29

This diff is too big to show here.

src/Idris/Help.hs+41−50

This diff is too big to show here.

src/Idris/IBC.hs+946−1680

This diff is too big to show here.

src/Idris/IdeMode.hsnew file+342

This diff is too big to show here.

src/Idris/IdeSlave.hsdeleted−152

This diff is too big to show here.

src/Idris/IdrisDoc.hsnew file+702

This diff is too big to show here.

src/Idris/Imports.hs+110−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+13−8

This diff is too big to show here.

src/Idris/Interactive.hsnew file+504

This diff is too big to show here.

src/Idris/Main.hsnew file+309

This diff is too big to show here.

src/Idris/ModeCommon.hsnew file+187

This diff is too big to show here.

src/Idris/Options.hsnew file+291

This diff is too big to show here.

src/Idris/Output.hsnew file+531

This diff is too big to show here.

src/Idris/Package.hsnew file+524

This diff is too big to show here.

src/Idris/Package/Common.hsnew file+41

This diff is too big to show here.

src/Idris/Package/Parser.hsnew file+148

This diff is too big to show here.

src/Idris/ParseData.hsdeleted−215

This diff is too big to show here.

src/Idris/ParseExpr.hsdeleted−1053

This diff is too big to show here.

src/Idris/ParseHelpers.hsdeleted−503

This diff is too big to show here.

src/Idris/ParseOps.hsdeleted−137

This diff is too big to show here.

src/Idris/Parser.hs+1400−625

This diff is too big to show here.

src/Idris/Parser/Data.hsnew file+304

This diff is too big to show here.

src/Idris/Parser/Expr.hsnew file+1580

This diff is too big to show here.

src/Idris/Parser/Helpers.hsnew file+559

This diff is too big to show here.

src/Idris/Parser/Ops.hsnew file+249

This diff is too big to show here.

src/Idris/Parser/Stack.hsnew file+161

This diff is too big to show here.

src/Idris/PartialEval.hs+347−74

This diff is too big to show here.

src/Idris/Primitives.hs+97−284

This diff is too big to show here.

src/Idris/ProofSearch.hs+475−55

This diff is too big to show here.

src/Idris/Prover.hs+491−142

This diff is too big to show here.

src/Idris/Providers.hs+42−19

This diff is too big to show here.

src/Idris/REPL.hs+1311−1041

This diff is too big to show here.

src/Idris/REPL/Browse.hsnew file+52

This diff is too big to show here.

src/Idris/REPL/Commands.hsnew file+81

This diff is too big to show here.

src/Idris/REPL/Parser.hsnew file+540

This diff is too big to show here.

src/Idris/REPLParser.hsdeleted−164

This diff is too big to show here.

src/Idris/Reflection.hsnew file+1230

This diff is too big to show here.

src/Idris/Termination.hsnew file+639

This diff is too big to show here.

src/Idris/Transforms.hs+104−52

This diff is too big to show here.

src/Idris/TypeSearch.hsnew file+564

This diff is too big to show here.

src/Idris/Unlit.hs+19−8

This diff is too big to show here.

src/Idris/UnusedArgs.hsdeleted−64

This diff is too big to show here.

src/Idris/WhoCalls.hsnew file+98

This diff is too big to show here.

src/Main.hsdeleted−111

This diff is too big to show here.

src/Pkg/PParser.hsdeleted−80

This diff is too big to show here.

src/Pkg/Package.hsdeleted−132

This diff is too big to show here.

src/Util/DynamicLinker.hs+135−34

This diff is too big to show here.

src/Util/LLVMStubs.hsdeleted−31

This diff is too big to show here.

src/Util/Net.hs+30−11

This diff is too big to show here.

src/Util/Pretty.hs+19−17

This diff is too big to show here.

src/Util/ScreenSize.hsnew file+13

This diff is too big to show here.

src/Util/System.hs+121−75

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.

stack.yamlnew file+1

This diff is too big to show here.

stylize.shnew file+40

This diff is too big to show here.

support/Makefiledeleted−15

This diff is too big to show here.

support/network.cdeleted−260

This diff is too big to show here.

support/network.hdeleted−36

This diff is too big to show here.

support/testidr.cdeleted−6

This diff is too big to show here.

support/testidr.hdeleted−7

This diff is too big to show here.

support/threads.cdeleted−116

This diff is too big to show here.

support/threads.hdeleted−11

This diff is too big to show here.

test/Makefiledeleted−108

This diff is too big to show here.

test/READMEdeleted−40

This diff is too big to show here.

test/README.mdnew file+160

This diff is too big to show here.

test/TestData.hsnew file+350

This diff is too big to show here.

test/TestRun.hsnew file+128

This diff is too big to show here.

test/base001/Makefilenew file+11

This diff is too big to show here.

test/base001/base001.idrnew file+35

This diff is too big to show here.

test/base001/base001.ipkgnew file+5

This diff is too big to show here.

test/base001/exit1.cnew file+21

This diff is too big to show here.

test/base001/expected.outnew file+25

This diff is too big to show here.

test/base001/run.shnew file+12

This diff is too big to show here.

test/base001/sys.cnew file+15

This diff is too big to show here.

test/base001/sys.hnew file+7

This diff is too big to show here.

test/basic001/basic001a.idrnew file+34

This diff is too big to show here.

test/reg005/expected → test/basic001/expected.outrenamed+1

This diff is too big to show here.

test/basic001/reg005.idrnew file+54

This diff is too big to show here.

test/basic001/run.shnew file+6

This diff is too big to show here.

test/basic002/expected.outnew file+13

This diff is too big to show here.

test/test006/run → test/basic002/run.shrenamed+1−1

This diff is too big to show here.

test/test006/test006.idr → test/basic002/test006.idrrenamed+10−11

This diff is too big to show here.

test/test027/expected → test/basic003/expected.outrenamed

The content is the same.

test/test027/run → test/basic003/run.shrenamed+1−1

This diff is too big to show here.

test/test027/test027.idr → test/basic003/test027.idrrenamed+3−3

This diff is too big to show here.

test/test016/expected → test/basic004/expected.outrenamed

The content is the same.

test/test016/run → test/basic004/run.shrenamed+1−1

This diff is too big to show here.

test/test016/test016.idr → test/basic004/test016.idrrenamed+1−1

This diff is too big to show here.

test/test019/expected → test/basic005/expected.outrenamed

The content is the same.

test/test019/run → test/basic005/run.shrenamed+1−1

This diff is too big to show here.

test/basic005/test019.lidrnew file+18

This diff is too big to show here.

test/basic006/expected.outnew file+15

This diff is too big to show here.

test/basic006/run.shnew file+6

This diff is too big to show here.

test/test020/test020.idr → test/basic006/test020.idrrenamed+4−2

This diff is too big to show here.

test/test020/test020a.idr → test/basic006/test020a.idrrenamed+3−1

This diff is too big to show here.

test/test033/expected → test/basic007/expected.outrenamed

The content is the same.

test/test033/run → test/basic007/run.shrenamed+1−1

This diff is too big to show here.

test/basic007/test033.idrnew file+4

This diff is too big to show here.

test/basic008/expected.outnew file+1

This diff is too big to show here.

test/basic008/run.shnew file+4

This diff is too big to show here.

test/basic008/test036.idrnew file+17

This diff is too big to show here.

test/basic009/A.idrnew file+5

This diff is too big to show here.

test/basic009/B/C.idrnew file+5

This diff is too big to show here.

test/basic009/Faulty.idrnew file+7

This diff is too big to show here.

test/basic009/Main.idrnew file+16

This diff is too big to show here.

test/basic009/Multiple.idrnew file+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/run.shnew file+8

This diff is too big to show here.

test/basic010/Main.idrnew file+43

This diff is too big to show here.

test/basic010/expected.outnew file+3

This diff is too big to show here.

test/basic010/run.shnew file+10

This diff is too big to show here.

test/basic011/basic011.idrnew file+20

This diff is too big to show here.

test/basic011/expected.outnew file+14

This diff is too big to show here.

test/basic011/run.shnew file+4

This diff is too big to show here.

test/basic012/basic012.idrnew file+63

This diff is too big to show here.

test/basic012/basic012a.idrnew file+10

This diff is too big to show here.

test/basic012/expected.outnew file+2

This diff is too big to show here.

test/basic012/run.shnew file+5

This diff is too big to show here.

test/basic013/basic013.idrnew file+78

This diff is too big to show here.

test/basic013/expected.outnew file+59

This diff is too big to show here.

test/basic013/run.shnew file+4

This diff is too big to show here.

test/basic014/basic014.idrnew file+44

This diff is too big to show here.

test/reg001/expected → test/basic014/expected.outrenamed

The content is the same.

test/basic014/run.shnew file+3

This diff is too big to show here.

test/basic015/basic015.idrnew file+73

This diff is too big to show here.

test/basic015/expected.outnew file+3

This diff is too big to show here.

test/basic015/run.shnew file+4

This diff is too big to show here.

test/basic016/CycleA.idrnew file+4

This diff is too big to show here.

test/basic016/CycleB.idrnew file+5

This diff is too big to show here.

test/basic016/CycleC.idrnew file+4

This diff is too big to show here.

test/basic016/expected.outnew file+1

This diff is too big to show here.

test/basic016/run.shnew file+3

This diff is too big to show here.

test/basic017/basic017.idrnew file+25

This diff is too big to show here.

test/basic017/basic017a.idrnew file+15

This diff is too big to show here.

test/basic017/expected.outnew file+8

This diff is too big to show here.

test/basic017/run.shnew file+4

This diff is too big to show here.

test/basic018/basic018.idrnew file+14

This diff is too big to show here.

test/basic018/expected.outnew file+32

This diff is too big to show here.

test/basic018/run.shnew file+3

This diff is too big to show here.

test/basic019/basic019.idrnew file+10

This diff is too big to show here.

test/basic019/expected.outnew file+12

This diff is too big to show here.

test/basic019/run.shnew file+4

This diff is too big to show here.

test/basic020/basic020.idrnew file+42

This diff is too big to show here.

test/basic020/expected.outnew file+1

This diff is too big to show here.

test/basic020/run.shnew file+4

This diff is too big to show here.

test/basic021/basic021.idrnew file+13

This diff is too big to show here.

test/basic021/basic021_2.idrnew file+13

This diff is too big to show here.

test/basic021/expected.outnew file+2

This diff is too big to show here.

test/basic021/run.shnew file+6

This diff is too big to show here.

test/basic022/basic022.idrnew file+13

This diff is too big to show here.

test/basic022/expected.outnew file+1

This diff is too big to show here.

test/basic022/run.shnew file+4

This diff is too big to show here.

test/basic023/expected.outnew file+10

This diff is too big to show here.

test/basic023/run.shnew file+4

This diff is too big to show here.

test/basic023/sections.idrnew file+34

This diff is too big to show here.

test/basic024/basic024.idrnew file+51

This diff is too big to show here.

test/basic024/expected.outnew file+76

This diff is too big to show here.

test/basic024/input.innew file+46

This diff is too big to show here.

test/basic024/run.shnew file+8

This diff is too big to show here.

test/basic025/basic025.idrnew file+28

This diff is too big to show here.

test/basic025/expected.outnew file+12

This diff is too big to show here.

test/basic025/input.innew file+7

This diff is too big to show here.

test/basic025/run.shnew file+7

This diff is too big to show here.

test/basic026/basic026.idrnew file+12

This diff is too big to show here.

test/basic026/expected.outnew file+2

This diff is too big to show here.

test/basic026/run.shnew file+4

This diff is too big to show here.

test/bignum001/bignum001.idrnew file+17

This diff is too big to show here.

test/bignum001/expected.outnew file+1

This diff is too big to show here.

test/bignum001/run.shnew file+4

This diff is too big to show here.

test/bignum002/bignum002.idrnew file+14

This diff is too big to show here.

test/bignum002/expected.outnew file+8

This diff is too big to show here.

test/bignum002/run.shnew file+4

This diff is too big to show here.

test/bignum003/bignum003.idrnew file+23

This diff is too big to show here.

test/bignum003/expected.outnew file+2

This diff is too big to show here.

test/bignum003/run.shnew file+4

This diff is too big to show here.

test/bounded001/bounded001.idrnew file+10

This diff is too big to show here.

test/bounded001/expected.outnew file+6

This diff is too big to show here.

test/bounded001/run.shnew file+4

This diff is too big to show here.

test/buffer001/buffer001.idrnew file+33

This diff is too big to show here.

test/buffer001/expected.outnew file+7

This diff is too big to show here.

test/buffer001/run.shnew file+4

This diff is too big to show here.

test/buffer002/buffer002.idrnew file+34

This diff is too big to show here.

test/buffer002/expected.outnew file+11

This diff is too big to show here.

test/buffer002/run.shnew file+4

This diff is too big to show here.

test/contrib001/contrib001.idrnew file+14

This diff is too big to show here.

test/contrib001/expected.outnew file+12

This diff is too big to show here.

test/contrib001/run.shnew file+4

This diff is too big to show here.

test/corecords001/corecords001.idrnew file+24

This diff is too big to show here.

test/corecords001/expected.outnew file+5

This diff is too big to show here.

test/corecords001/run.shnew file+4

This diff is too big to show here.

test/corecords002/corecords002.idrnew file+24

This diff is too big to show here.

test/corecords002/expected.outnew file+3

This diff is too big to show here.

test/corecords002/run.shnew file+4

This diff is too big to show here.

test/delab001/delab001.idrnew file+16

This diff is too big to show here.

test/delab001/expected.outnew file+12

This diff is too big to show here.

test/delab001/input.innew file+4

This diff is too big to show here.

test/delab001/run.shnew file+3

This diff is too big to show here.

test/directives001/directives001.idrnew file+28

This diff is too big to show here.

test/directives001/expected.outnew file+42

This diff is too big to show here.

test/directives001/run.shnew file+4

This diff is too big to show here.

test/directives002/directives002.idrnew file+14

This diff is too big to show here.

test/directives002/expected.outnew file+6

This diff is too big to show here.

test/directives002/run.shnew file+4

This diff is too big to show here.

test/directives003/directives003.idrnew file+11

This diff is too big to show here.

test/directives003/expected.outnew file+6

This diff is too big to show here.

test/directives003/run.shnew file+13

This diff is too big to show here.

test/disambig002/disambig002.idrnew file+84

This diff is too big to show here.

test/reg008/expected → test/disambig002/expected.outrenamed

The content is the same.

test/disambig002/run.shnew file+3

This diff is too big to show here.

test/docs001/docs001.idrnew file+20

This diff is too big to show here.

test/docs001/expected.outnew file+17

This diff is too big to show here.

test/docs001/input.innew file+1

This diff is too big to show here.

test/docs001/run.shnew file+3

This diff is too big to show here.

test/docs002/docs002.idrnew file+17

This diff is too big to show here.

test/docs002/expected.outnew file+12

This diff is too big to show here.

test/docs002/input.innew file+3

This diff is too big to show here.

test/docs002/run.shnew file+3

This diff is too big to show here.

test/docs003/docs003.idrnew file+9

This diff is too big to show here.

test/docs003/expected.outnew file+41

This diff is too big to show here.

test/docs003/input.innew file+3

This diff is too big to show here.

test/docs003/run.shnew file+3

This diff is too big to show here.

test/docs004/docs004.idrnew file+11

This diff is too big to show here.

test/docs004/expected.outnew file+18

This diff is too big to show here.

test/docs004/input.innew file+3

This diff is too big to show here.

test/docs004/run.shnew file+3

This diff is too big to show here.

test/docs005/docs005.idrnew file+19

This diff is too big to show here.

test/docs005/expected.outnew file+31

This diff is too big to show here.

test/docs005/input.innew file+2

This diff is too big to show here.

test/docs005/run.shnew file+3

This diff is too big to show here.

test/docs006/docs006.idrnew file+7

This diff is too big to show here.

test/docs006/expected.outnew file+16

This diff is too big to show here.

test/docs006/input.innew file+1

This diff is too big to show here.

test/docs006/run.shnew file+3

This diff is too big to show here.

test/dsl001/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.

test/dsl001/run.shnew file+5

This diff is too big to show here.

test/test001/test001.idr → test/dsl001/test001.idrrenamed+29−20

This diff is too big to show here.

test/test014/Resimp.idr → test/dsl002/Resimp.idrrenamed+38−27

This diff is too big to show here.

test/test014/expected → test/dsl002/expected.outrenamed−1

This diff is too big to show here.

test/dsl002/run.shnew file+4

This diff is too big to show here.

test/test014/test → test/dsl002/test.inrenamed

The content is the same.

test/test014/test014.idr → test/dsl002/test014.idrrenamed+13−10

This diff is too big to show here.

test/dsl003/DSLPi.idrnew file+49

This diff is too big to show here.

test/dsl003/expected.outnew file+2

This diff is too big to show here.

test/dsl003/run.shnew file+3

This diff is too big to show here.

test/dsl004/Door0.idrnew file+35

This diff is too big to show here.

test/dsl004/Door1.idrnew file+39

This diff is too big to show here.

test/dsl004/Door2.idrnew file+39

This diff is too big to show here.

test/dsl004/Door3.idrnew file+32

This diff is too big to show here.

test/dsl004/IOu.idrnew file+21

This diff is too big to show here.

test/reg009/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.outnew file+4

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.idrnew file+48

This diff is too big to show here.

test/test021/test021a.idr → test/effects001/test021a.idrrenamed+6−5

This diff is too big to show here.

test/test021/testFile → test/effects001/testFile.inrenamed

The content is the same.

test/test025/expected → test/effects002/expected.outrenamed

The content is the same.

test/effects002/run.shnew file+4

This diff is too big to show here.

test/effects002/test025.idrnew file+35

This diff is too big to show here.

test/effects003/VectMissing.idrnew file+12

This diff is too big to show here.

test/effects003/expected.outnew file+31

This diff is too big to show here.

test/effects003/hangman.idrnew file+229

This diff is too big to show here.

test/effects003/input.innew file+6

This diff is too big to show here.

test/effects003/run.shnew file+4

This diff is too big to show here.

test/effects004/effects004.idrnew file+19

This diff is too big to show here.

test/effects004/expected.outnew file+11

This diff is too big to show here.

test/effects004/input.innew file+10

This diff is too big to show here.

test/effects004/run.shnew file+4

This diff is too big to show here.

test/effects005/categoryLogger.idrnew file+23

This diff is too big to show here.

test/effects005/defaultLogger.idrnew file+14

This diff is too big to show here.

test/effects005/expected.outnew file+5

This diff is too big to show here.

test/effects005/run.shnew file+6

This diff is too big to show here.

test/error001/expected.outnew file+13

This diff is too big to show here.

test/test002/expected_ttquot → test/error001/expected_ttquotrenamed

The content is the same.

test/error001/run.shnew file+3

This diff is too big to show here.

test/test002/test002.idr → test/error001/test002.idrrenamed

The content is the same.

test/reg011/expected → test/error002/expected.outrenamed

The content is the same.

test/test031/run → test/error002/run.shrenamed+1−1

This diff is too big to show here.

test/test031/test031.idr → test/error002/test031.idrrenamed+1−1

This diff is too big to show here.

test/error003/ErrorReflection.idrnew file+69

This diff is too big to show here.

test/error003/expected.outnew file+9

This diff is too big to show here.

test/error003/run.shnew file+3

This diff is too big to show here.

test/error004/FunErrTest.idrnew file+42

This diff is too big to show here.

test/error004/expected.outnew file+20

This diff is too big to show here.

test/error004/run.shnew file+3

This diff is too big to show here.

test/error005/error005.idrnew file+27

This diff is too big to show here.

test/error005/expected.outnew file+56

This diff is too big to show here.

test/error005/run.shnew file+3

This diff is too big to show here.

test/error006/WithPatsNoWith.idrnew file+17

This diff is too big to show here.

test/error006/expected.outnew file+21

This diff is too big to show here.

test/error006/run.shnew file+3

This diff is too big to show here.

test/error007/error007.idrnew file+29

This diff is too big to show here.

test/error007/expected.outnew file+19

This diff is too big to show here.

test/error007/run.shnew file+3

This diff is too big to show here.

test/error008/error008.idrnew file+5

This diff is too big to show here.

test/error008/error008a.idrnew file+5

This diff is too big to show here.

test/error008/expected.outnew file+14

This diff is too big to show here.

test/error008/run.shnew file+4

This diff is too big to show here.

test/error009/expected.outnew file+1

This diff is too big to show here.

test/error009/run.shnew file+2

This diff is too big to show here.

test/ffi001/expected.outnew file+1

This diff is too big to show here.

test/ffi001/run.shnew file+3

This diff is too big to show here.

test/ffi001/test022.idrnew file+9

This diff is too big to show here.

test/ffi002/expected.outnew file+6

This diff is too big to show here.

test/ffi002/run.shnew file+3

This diff is too big to show here.

test/test023/test023.idr → test/ffi002/test023.idrrenamed+4−6

This diff is too big to show here.

test/ffi003/expected.outnew file+1

This diff is too big to show here.

test/ffi003/input.innew file+1

This diff is too big to show here.

test/ffi003/run.shnew file+3

This diff is too big to show here.

test/test024/test024.idr → test/ffi003/test024.idrrenamed

The content is the same.

test/reg012/expected → test/ffi004/expected.outrenamed

The content is the same.

test/ffi004/run.shnew file+3

This diff is too big to show here.

test/test026/test026.idr → test/ffi004/test026.idrrenamed+8−4

This diff is too big to show here.

test/ffi004/theOtherTypenew file+1

This diff is too big to show here.

test/test026/theType → test/ffi004/theTyperenamed

The content is the same.

test/ffi005/Postulate.idrnew file+12

This diff is too big to show here.

test/ffi005/expected.outnew file+1

This diff is too big to show here.

test/ffi005/run.shnew file+5

This diff is too big to show here.

test/ffi006/expected.outnew file+2

This diff is too big to show here.

test/ffi006/ffi006.cnew file+14

This diff is too big to show here.

test/ffi006/ffi006.idrnew file+30

This diff is too big to show here.

test/ffi006/run.shnew file+5

This diff is too big to show here.

test/ffi007/expected.outnew file+10

This diff is too big to show here.

test/ffi007/ffi007.cnew file+34

This diff is too big to show here.

test/ffi007/ffi007.hnew file+15

This diff is too big to show here.

test/ffi007/ffi007.idrnew file+63

This diff is too big to show here.

test/ffi007/run.shnew file+4

This diff is too big to show here.

test/ffi008/expected.outnew file+5

This diff is too big to show here.

test/ffi008/ffi008.cnew file+25

This diff is too big to show here.

test/ffi008/ffi008.hnew file+19

This diff is too big to show here.

test/ffi008/ffi008.idrnew file+58

This diff is too big to show here.

test/ffi008/run.shnew file+4

This diff is too big to show here.

test/ffi009/Bad.idrnew file+36

This diff is too big to show here.

test/ffi009/Good.idrnew file+37

This diff is too big to show here.

test/ffi009/expected.outnew file+1

This diff is too big to show here.

test/ffi009/ffi009.cnew file+44

This diff is too big to show here.

test/ffi009/ffi009.hnew file+20

This diff is too big to show here.

test/ffi009/run.shnew file+5

This diff is too big to show here.

test/ffi010/expected.outnew file+3

This diff is too big to show here.

test/ffi010/ffi010.idrnew file+43

This diff is too big to show here.

test/ffi010/run.shnew file+4

This diff is too big to show here.

test/ffi011/expected.outnew file+2

This diff is too big to show here.

test/ffi011/ffi011.idrnew file+27

This diff is too big to show here.

test/ffi011/ffi011.jsnew file+7

This diff is too big to show here.

test/ffi011/run.shnew file+4

This diff is too big to show here.

test/ffi012/expected.outnew file+1

This diff is too big to show here.

test/ffi012/ffi012.idrnew file+14

This diff is too big to show here.

test/ffi012/ffi012.jsnew file+3

This diff is too big to show here.

test/ffi012/run.shnew file+4

This diff is too big to show here.

test/ffi013/expected.outnew file+4

This diff is too big to show here.

test/ffi013/ffi013.idrnew file+5

This diff is too big to show here.

test/ffi013/run.shnew file+17

This diff is too big to show here.

test/folding001/expected.outnew file+4

This diff is too big to show here.

test/folding001/folding001.idrnew file+25

This diff is too big to show here.

test/folding001/run.shnew file+4

This diff is too big to show here.

test/idrisdoc001/TestEmpty.idrnew file+1

This diff is too big to show here.

test/idrisdoc001/TestPrivate.idrnew file+5

This diff is too big to show here.

test/idrisdoc001/expected.outnew file+3

This diff is too big to show here.

test/idrisdoc001/run.shnew file+4

This diff is too big to show here.

test/idrisdoc001/test_empty.ipkgnew file+6

This diff is too big to show here.

test/idrisdoc002/TestFunctions.idrnew file+6

This diff is too big to show here.

test/idrisdoc002/expected.outnew file+1

This diff is too big to show here.

test/idrisdoc002/run.shnew file+5

This diff is too big to show here.

test/idrisdoc002/test_functions.ipkgnew file+6

This diff is too big to show here.

test/idrisdoc003/TestDatatypes.idrnew file+7

This diff is too big to show here.

test/idrisdoc003/expected.outnew file+1

This diff is too big to show here.

test/idrisdoc003/run.shnew file+5

This diff is too big to show here.

test/idrisdoc003/test_datatypes.ipkgnew file+6

This diff is too big to show here.

test/idrisdoc004/TestInterfaces.idrnew file+9

This diff is too big to show here.

test/idrisdoc004/expected.outnew file+1

This diff is too big to show here.

test/idrisdoc004/run.shnew file+5

This diff is too big to show here.

test/idrisdoc004/test_interfaces.ipkgnew file+6

This diff is too big to show here.

test/idrisdoc005/TestTracing.idrnew file+5

This diff is too big to show here.

test/idrisdoc005/expected.outnew file+2

This diff is too big to show here.

test/idrisdoc005/run.shnew file+6

This diff is too big to show here.

test/idrisdoc005/test_tracing.ipkgnew file+6

This diff is too big to show here.

test/idrisdoc006/A/fully/Qualified/NAME.idrnew file+6

This diff is too big to show here.

test/idrisdoc006/B.idrnew file+6

This diff is too big to show here.

test/idrisdoc006/expected.outnew file+5

This diff is too big to show here.

test/idrisdoc006/package_a.ipkgnew file+6

This diff is too big to show here.

test/idrisdoc006/package_b.ipkgnew file+6

This diff is too big to show here.

test/idrisdoc006/run.shnew file+17

This diff is too big to show here.

test/idrisdoc007/A.idrnew file+6

This diff is too big to show here.

test/idrisdoc007/expected.outnew file+1

This diff is too big to show here.

test/idrisdoc007/package.ipkgnew file+6

This diff is too big to show here.

test/idrisdoc007/run.shnew file+6

This diff is too big to show here.

test/idrisdoc008/Abstract.idrnew file+5

This diff is too big to show here.

test/idrisdoc008/Visible.idrnew file+5

This diff is too big to show here.

test/idrisdoc008/expected.outnew file+2

This diff is too big to show here.

test/idrisdoc008/run.shnew file+6

This diff is too big to show here.

test/idrisdoc008/visibility.ipkgnew file+6

This diff is too big to show here.

test/idrisdoc009/Test.idrnew file+47

This diff is too big to show here.

test/idrisdoc009/expected.outnew file+30

This diff is too big to show here.

test/idrisdoc009/input.innew file+2

This diff is too big to show here.

test/idrisdoc009/run.shnew file+3

This diff is too big to show here.

test/interactive001/expected.outnew file+20

This diff is too big to show here.

test/interactive001/input.innew file+8

This diff is too big to show here.

test/test032/test032.idr → test/interactive001/interactive001.idrrenamed+13

This diff is too big to show here.

test/interactive001/run.shnew file+5

This diff is too big to show here.

test/interactive002/expected.outnew file+10

This diff is too big to show here.

test/interactive002/input.innew file+11

This diff is too big to show here.

test/interactive002/interactive002.idrnew file+21

This diff is too big to show here.

test/interactive002/run.shnew file+3

This diff is too big to show here.

test/interactive003/expected.outnew file+5

This diff is too big to show here.

test/interactive003/input.innew file+5

This diff is too big to show here.

test/interactive003/interactive003.idrnew file+15

This diff is too big to show here.

test/interactive003/run.shnew file+3

This diff is too big to show here.

test/interactive004/expected.outnew file+2

This diff is too big to show here.

test/interactive004/input.innew file+2

This diff is too big to show here.

test/interactive004/interactive004.idrnew file+9

This diff is too big to show here.

test/interactive004/run.shnew file+3

This diff is too big to show here.

test/interactive005/expected.outnew file+36

This diff is too big to show here.

test/interactive005/input.innew file+26

This diff is too big to show here.

test/interactive005/interactive005.idrnew file+3

This diff is too big to show here.

test/interactive005/run.shnew file+6

This diff is too big to show here.

test/interactive006/expected.outnew file+1

This diff is too big to show here.

test/interactive006/input.innew file+1

This diff is too big to show here.

test/interactive006/interactive006.idrnew file+3

This diff is too big to show here.

test/interactive006/run.shnew file+3

This diff is too big to show here.

test/interactive007/expected.outnew file+1

This diff is too big to show here.

test/interactive007/input.innew file+4

This diff is too big to show here.

test/interactive007/run.shnew file+2

This diff is too big to show here.

test/interactive008/expected.outnew file+204

This diff is too big to show here.

test/interactive008/input.innew file+9

This diff is too big to show here.

test/interactive008/run.shnew file+2

This diff is too big to show here.

test/interactive009/expected.outnew file+1

This diff is too big to show here.

test/interactive009/input.innew file+1

This diff is too big to show here.

test/interactive009/interactive009.idrnew file+27

This diff is too big to show here.

test/interactive009/run.shnew file+3

This diff is too big to show here.

test/interactive010/expected.outnew file+24

This diff is too big to show here.

test/interactive010/input.innew file+9

This diff is too big to show here.

test/interactive010/run.shnew file+2

This diff is too big to show here.

test/interactive011/.gitignorenew file+1

This diff is too big to show here.

test/interactive011/expected.outnew file+3

This diff is too big to show here.

test/interactive011/input.innew file+2

This diff is too big to show here.

test/interactive011/interactive011.ipkgnew file+8

This diff is too big to show here.

test/interactive011/run.shnew file+6

This diff is too big to show here.

test/interactive011/src/Foo.idrnew file+5

This diff is too big to show here.

test/interactive011/src/Main.idrnew file+14

This diff is too big to show here.

test/interactive012/expected.outnew file+33

This diff is too big to show here.

test/interactive012/input.innew file+9

This diff is too big to show here.

test/interactive012/interactive012.idrnew file+26

This diff is too big to show here.

test/interactive012/run.shnew file+3

This diff is too big to show here.

test/interactive013/expected.outnew file+4

This diff is too big to show here.

test/interactive013/input.innew file+1

This diff is too big to show here.

test/interactive013/interactive013.idrnew file+4

This diff is too big to show here.

test/interactive013/run.shnew file+3

This diff is too big to show here.

test/interactive014/expected.outnew file+7

This diff is too big to show here.

test/interactive014/input.innew file+5

This diff is too big to show here.

test/interactive014/interactive014.idrnew file+10

This diff is too big to show here.

test/interactive014/run.shnew file+3

This diff is too big to show here.

test/interactive015/expected.outnew file+6

This diff is too big to show here.

test/interactive015/input.innew file+2

This diff is too big to show here.

test/interactive015/run.shnew file+8

This diff is too big to show here.

test/interactive015/src/interactive015.idrnew file+4

This diff is too big to show here.

test/interactive016/expected.outnew file+7

This diff is too big to show here.

test/interactive016/input.innew file+2

This diff is too big to show here.

test/interactive016/run.shnew file+8

This diff is too big to show here.

test/interactive016/src/interactive016.idrnew file+7

This diff is too big to show here.

test/interactive017/TestMod.idrnew file+5

This diff is too big to show here.

test/interactive017/expected.outnew file+7

This diff is too big to show here.

test/interactive017/run.shnew file+9

This diff is too big to show here.

test/interactive017/shebang-args.idrnew file+6

This diff is too big to show here.

test/interactive017/shebang-import.idrnew file+6

This diff is too big to show here.

test/interactive017/shebang-node.idrnew file+4

This diff is too big to show here.

test/interactive017/shebang.idrnew file+4

This diff is too big to show here.

test/interactive018/Imported1.idrnew file+10

This diff is too big to show here.

test/interactive018/Imported2.idrnew file+8

This diff is too big to show here.

test/interactive018/Public1.idrnew file+10

This diff is too big to show here.

test/interactive018/Public2.idrnew file+8

This diff is too big to show here.

test/interactive018/Top.idrnew file+11

This diff is too big to show here.

test/interactive018/expected.outnew file+20

This diff is too big to show here.

test/interactive018/input.innew file+20

This diff is too big to show here.

test/interactive018/run.shnew file+3

This diff is too big to show here.

test/interfaces001/InterfaceName.idrnew file+49

This diff is too big to show here.

test/interfaces001/expected.outnew file+30

This diff is too big to show here.

test/interfaces001/input.innew file+2

This diff is too big to show here.

test/interfaces001/run.shnew file+3

This diff is too big to show here.

test/interfaces002/expected.outnew file+1

This diff is too big to show here.

test/interfaces002/interfaces002.idrnew file+38

This diff is too big to show here.

test/interfaces002/run.shnew file+4

This diff is too big to show here.

test/interfaces003/expected.outnew file+2

This diff is too big to show here.

test/interfaces003/interfaces003.idrnew file+22

This diff is too big to show here.

test/interfaces003/run.shnew file+4

This diff is too big to show here.

test/interfaces004/expected.outnew file+4

This diff is too big to show here.

test/interfaces004/interfaces004.idrnew file+35

This diff is too big to show here.

test/interfaces004/run.shnew file+4

This diff is too big to show here.

test/interfaces005/expected.outnew file+7

This diff is too big to show here.

test/interfaces005/interfaces005.idrnew file+53

This diff is too big to show here.

test/interfaces005/interfaces005a.idrnew file+50

This diff is too big to show here.

test/interfaces005/interfaces005b.idrnew file+50

This diff is too big to show here.

test/interfaces005/run.shnew file+5

This diff is too big to show here.

test/reg014/expected → test/interfaces006/expected.outrenamed

The content is the same.

test/interfaces006/interfaces006.idrnew file+19

This diff is too big to show here.

test/interfaces006/run.shnew file+3

This diff is too big to show here.

test/interfaces007/expected.outnew file+1

This diff is too big to show here.

test/interfaces007/interfaces007.idrnew file+52

This diff is too big to show here.

test/interfaces007/run.shnew file+4

This diff is too big to show here.

test/interfaces008/expected.outnew file+6

This diff is too big to show here.

test/interfaces008/interfaces008.idrnew file+20

This diff is too big to show here.

test/interfaces008/run.shnew file+3

This diff is too big to show here.

test/reg015/expected → test/interfaces009/expected.outrenamed

The content is the same.

test/interfaces009/interfaces009.idrnew file+24

This diff is too big to show here.

test/interfaces009/run.shnew file+3

This diff is too big to show here.

test/reg019/expected → test/interfaces010/expected.outrenamed

The content is the same.

test/interfaces010/interfaces010.idrnew file+12

This diff is too big to show here.

test/interfaces010/run.shnew file+3

This diff is too big to show here.

test/interpret001/double-echo.idrnew file+6

This diff is too big to show here.

test/interpret001/expected.outnew file+2

This diff is too big to show here.

test/interpret001/input.innew file+2

This diff is too big to show here.

test/interpret001/run.shnew file+3

This diff is too big to show here.

test/interpret002/expected.outnew file+4

This diff is too big to show here.

test/interpret002/file-error.idrnew file+6

This diff is too big to show here.

test/interpret002/input.innew file+2

This diff is too big to show here.

test/interpret002/readable.txtnew file+1

This diff is too big to show here.

test/interpret002/run.shnew file+3

This diff is too big to show here.

test/interpret003/expected.outnew file+1

This diff is too big to show here.

test/interpret003/input.innew file+1

This diff is too big to show here.

test/interpret003/interpret003.idrnew file+4

This diff is too big to show here.

test/interpret003/run.shnew file+3

This diff is too big to show here.

test/interpret003/testnew file

Binary file not shown.

test/test004/expected → test/io001/expected.outrenamed

The content is the same.

test/test004/run → test/io001/run.shrenamed+1−1

This diff is too big to show here.

test/test004/test004.idr → test/io001/test004.idrrenamed+9−9

This diff is too big to show here.

test/test008/expected → test/io002/expected.outrenamed

The content is the same.

test/test008/run → test/io002/run.shrenamed+1−1

This diff is too big to show here.

test/test008/test008.idr → test/io002/test008.idrrenamed+3−3

This diff is too big to show here.

test/test018/expected → test/io003/expected.outrenamed

The content is the same.

test/io003/run.shnew file+6

This diff is too big to show here.

test/test018/test018.idr → test/io003/test018.idrrenamed+6−4

This diff is too big to show here.

test/test018/test018a.idr → test/io003/test018a.idrrenamed+11−8

This diff is too big to show here.

test/layout001/expected.outnew file+82

This diff is too big to show here.

test/layout001/layout001a.idrnew file+5

This diff is too big to show here.

test/layout001/layout001b.idrnew file+5

This diff is too big to show here.

test/layout001/layout001c.idrnew file+3

This diff is too big to show here.

test/layout001/layout001d.idrnew file+3

This diff is too big to show here.

test/layout001/layout001e.idrnew file+6

This diff is too big to show here.

test/layout001/layout001f.idrnew file+6

This diff is too big to show here.

test/layout001/layout001g.idrnew file+6

This diff is too big to show here.

test/layout001/layout001h.idrnew file+6

This diff is too big to show here.

test/layout001/layout001i.idrnew file+6

This diff is too big to show here.

test/layout001/layout001j.idrnew file+6

This diff is too big to show here.

test/layout001/layout001k.idrnew file+6

This diff is too big to show here.

test/layout001/layout001l.idrnew file+6

This diff is too big to show here.

test/layout001/layout001n.idrnew file+33

This diff is too big to show here.

test/layout001/mplus1.idrnew file+17

This diff is too big to show here.

test/layout001/mplus2.idrnew file+17

This diff is too big to show here.

test/layout001/mplus3.idrnew file+17

This diff is too big to show here.

test/layout001/run.shnew file+22

This diff is too big to show here.

test/test003/Lit.lidr → test/literate001/Lit.lidrrenamed+2−2

This diff is too big to show here.

test/literate001/expected.outnew file+12

This diff is too big to show here.

test/literate001/run.shnew file+5

This diff is too big to show here.

test/test003/test003.lidr → test/literate001/test003.lidrrenamed

The content is the same.

test/test003/test003a.lidr → test/literate001/test003a.lidrrenamed

The content is the same.

test/meta001/Finite.idrnew file+188

This diff is too big to show here.

test/reg021/expected → test/meta001/expected.outrenamed

The content is the same.

test/meta001/run.shnew file+3

This diff is too big to show here.

test/meta002/AgdaStyleReflection.idrnew file+320

This diff is too big to show here.

test/meta002/DataDef.idrnew file+75

This diff is too big to show here.

test/meta002/Deriving.idrnew file+35

This diff is too big to show here.

test/meta002/Tacs.idrnew file+304

This diff is too big to show here.

test/meta002/expected.outnew file+25

This diff is too big to show here.

test/meta002/run.shnew file+7

This diff is too big to show here.

test/meta003/BadDef.idrnew file+14

This diff is too big to show here.

test/meta003/Catch.idrnew file+17

This diff is too big to show here.

test/meta003/expected.outnew file+12

This diff is too big to show here.

test/meta003/run.shnew file+5

This diff is too big to show here.

test/meta004/expected.outnew file+7

This diff is too big to show here.

test/meta004/meta004.idrnew file+50

This diff is too big to show here.

test/meta004/run.shnew file+3

This diff is too big to show here.

test/mktest.pl+1−1

This diff is too big to show here.

test/pkg001/Main.idrnew file+8

This diff is too big to show here.

test/pkg001/expected.outnew file+23

This diff is too big to show here.

test/pkg001/run.shnew file+8

This diff is too big to show here.

test/pkg001/test-pkg.ipkgnew file+17

This diff is too big to show here.

test/pkg002/Main.idrnew file+4

This diff is too big to show here.

test/reg022/expected → test/pkg002/expected.outrenamed

The content is the same.

test/pkg002/run.shnew file+5

This diff is too big to show here.

test/pkg002/test.ipkgnew file+8

This diff is too big to show here.

test/pkg003/Main.idrnew file+4

This diff is too big to show here.

test/reg026/expected → test/pkg003/expected.outrenamed

The content is the same.

test/pkg003/run.shnew file+6

This diff is too big to show here.

test/pkg003/test.ipkgnew file+7

This diff is too big to show here.

test/pkg004/Main.idrnew file+4

This diff is too big to show here.

test/pkg004/expected.outnew file+6

This diff is too big to show here.

test/pkg004/run.shnew file+6

This diff is too big to show here.

test/pkg004/test.ipkgnew file+8

This diff is too big to show here.

test/pkg005/expected.outnew file+1

This diff is too big to show here.

test/pkg005/run.shnew file+3

This diff is too big to show here.

test/pkg005/test.ipkgnew file+3

This diff is too big to show here.

test/pkg006/expected.outnew file+1

This diff is too big to show here.

test/pkg006/run.shnew file+3

This diff is too big to show here.

test/pkg006/test.ipkgnew file+3

This diff is too big to show here.

test/pkg007/expected.outnew file+1

This diff is too big to show here.

test/pkg007/input.innew file+4

This diff is too big to show here.

test/pkg007/run.shnew file+7

This diff is too big to show here.

test/pkg007/toy/Toy.idrnew file+4

This diff is too big to show here.

test/pkg007/toy/Toy/Vehicle.idrnew file+4

This diff is too big to show here.

test/pkg007/toy/Toy/Vehicle/Car.idrnew file+3

This diff is too big to show here.

test/pkg007/toy/toy.ipkgnew file+7

This diff is too big to show here.

test/pkg008/expected.outnew file+13

This diff is too big to show here.

test/pkg008/maths.ipkgnew file+10

This diff is too big to show here.

test/pkg008/run.shnew file+11

This diff is too big to show here.

test/pkg008/src/NumOps.idrnew file+9

This diff is too big to show here.

test/pkg008/src/Test.idrnew file+21

This diff is too big to show here.

test/pkg009/datatype.ipkgnew file+6

This diff is too big to show here.

test/pkg009/expected.outnew file+9

This diff is too big to show here.

test/pkg009/run.shnew file+7

This diff is too big to show here.

test/pkg009/src/Data/Type.idrnew file+3

This diff is too big to show here.

test/pkg010/expected.outnew file+29

This diff is too big to show here.

test/pkg010/run.shnew file+2

This diff is too big to show here.

test/pkg010/wrongopts.ipkgnew file+3

This diff is too big to show here.

test/prelude001/expected.outnew file+10

This diff is too big to show here.

test/prelude001/prelude001.idrnew file+14

This diff is too big to show here.

test/prelude001/run.shnew file+4

This diff is too big to show here.

test/primitives001/expected.outnew file+27

This diff is too big to show here.

test/primitives001/input.innew file+2

This diff is too big to show here.

test/primitives001/run.shnew file+6

This diff is too big to show here.

test/primitives001/substring.idrnew file+58

This diff is too big to show here.

test/primitives001/test005.idrnew file+14

This diff is too big to show here.

test/test034/expected → test/primitives002/expected.outrenamed+20−18

This diff is too big to show here.

test/primitives002/run.shnew file+54

This diff is too big to show here.

test/primitives003/expected.outnew file+31

This diff is too big to show here.

test/primitives003/run.shnew file+5

This diff is too big to show here.

test/primitives003/test038.idrnew file+66

This diff is too big to show here.

test/primitives004-disabled/expected.outnew file+4

This diff is too big to show here.

test/primitives004-disabled/primitives004.idrnew file+8

This diff is too big to show here.

test/primitives004-disabled/run.shnew file+4

This diff is too big to show here.

test/primitives005/expected.outnew file+2

This diff is too big to show here.

test/primitives005/primitives005.idrnew file+24

This diff is too big to show here.

test/primitives005/run.shnew file+5

This diff is too big to show here.

test/primitives006/Data/ByteArray.idrnew file+100

This diff is too big to show here.

test/primitives006/Data/Bytes.idrnew file+286

This diff is too big to show here.

test/primitives006/array.cnew file+62

This diff is too big to show here.

test/primitives006/array.hnew file+18

This diff is too big to show here.

test/primitives006/expected.outnew file+9

This diff is too big to show here.

test/primitives006/load-test.idrnew file+48

This diff is too big to show here.

test/primitives006/run.shnew file+6

This diff is too big to show here.

test/proof001/expected.outnew file+12

This diff is too big to show here.

test/proof001/run.shnew file+3

This diff is too big to show here.

test/test029/test029.idr → test/proof001/test029.idrrenamed+11−8

This diff is too big to show here.

test/test030/Reflect.idr → test/proof002/Reflect.idrrenamed+61−59

This diff is too big to show here.

test/proof002/expected.outnew file+37

This diff is too big to show here.

test/proof002/run.shnew file+4

This diff is too big to show here.

test/test030/test030.idr → test/proof002/test030.idrrenamed−1

This diff is too big to show here.

test/test030/test030a.idr → test/proof002/test030a.idrrenamed

The content is the same.

test/test015/Parity.idr → test/proof003/Parity.idrrenamed+8−6

This diff is too big to show here.

test/proof003/expected.outnew file+39

This diff is too big to show here.

test/proof003/run.shnew file+4

This diff is too big to show here.

test/test015/test015.idr → test/proof003/test015.idrrenamed+38−34

This diff is too big to show here.

test/test029/expected → test/proof004/expected.outrenamed

The content is the same.

test/proof004/run.shnew file+3

This diff is too big to show here.

test/proof004/test035.idrnew file+9

This diff is too big to show here.

test/proof005/DefaultArgSubstitutionSuccess.idrnew file+44

This diff is too big to show here.

test/test031/expected → test/proof005/expected.outrenamed

The content is the same.

test/proof005/run.shnew file+3

This diff is too big to show here.

test/proof006/DefaultArgSubstitutionSyntax.idrnew file+49

This diff is too big to show here.

test/proof006/expected.outnew file

No changes to the content.

test/proof006/run.shnew file+3

This diff is too big to show here.

test/proof007/DefaultArgUnknownName.idrnew file+10

This diff is too big to show here.

test/proof007/expected.outnew file+10

This diff is too big to show here.

test/proof007/run.shnew file+3

This diff is too big to show here.

test/proof008/ClaimAndUnfocus.idrnew file+17

This diff is too big to show here.

test/proof008/expected.outnew file+6

This diff is too big to show here.

test/proof008/run.shnew file+3

This diff is too big to show here.

test/proof009/expected.outnew file+26

This diff is too big to show here.

test/proof009/input.innew file+6

This diff is too big to show here.

test/proof009/proof009.idrnew file+9

This diff is too big to show here.

test/proof009/run.shnew file+3

This diff is too big to show here.

test/proof010/expected.outnew file+6

This diff is too big to show here.

test/proof010/proof010.idrnew file+37

This diff is too big to show here.

test/proof010/run.shnew file+4

This diff is too big to show here.

test/proof011/expected.outnew file+28

This diff is too big to show here.

test/proof011/proof011.idrnew file+21

This diff is too big to show here.

test/proof011/proof011a.idrnew file+14

This diff is too big to show here.

test/proof011/run.shnew file+4

This diff is too big to show here.

test/proofsearch001/expected.outnew file

No changes to the content.

test/proofsearch001/proofsearch001.idrnew file+11

This diff is too big to show here.

test/proofsearch001/run.shnew file+3

This diff is too big to show here.

test/proofsearch002/Process.idrnew file+444

This diff is too big to show here.

test/proofsearch002/expected.outnew file

No changes to the content.

test/proofsearch002/proofsearch002.idrnew file+48

This diff is too big to show here.

test/proofsearch002/run.shnew file+3

This diff is too big to show here.

test/proofsearch003/expected.outnew file

No changes to the content.

test/proofsearch003/proofsearch003.idrnew file+34

This diff is too big to show here.

test/proofsearch003/run.shnew file+3

This diff is too big to show here.

test/pruviloj001/expected.outnew file

No changes to the content.

test/pruviloj001/pruviloj001.idrnew file+84

This diff is too big to show here.

test/pruviloj001/run.shnew file+3

This diff is too big to show here.

test/quasiquote001/QuasiquoteBasics.idrnew file+27

This diff is too big to show here.

test/quasiquote001/expected.outnew file+5

This diff is too big to show here.

test/quasiquote001/run.shnew file+4

This diff is too big to show here.

test/quasiquote002/GoalQQuote.idrnew file+31

This diff is too big to show here.

test/quasiquote002/expected.outnew file+1

This diff is too big to show here.

test/quasiquote002/run.shnew file+4

This diff is too big to show here.

test/quasiquote003/NoInfer.idrnew file+11

This diff is too big to show here.

test/quasiquote003/expected.outnew file+9

This diff is too big to show here.

test/quasiquote003/run.shnew file+3

This diff is too big to show here.

test/quasiquote004/Quasiquote004.idrnew file+51

This diff is too big to show here.

test/quasiquote004/expected.outnew file+27

This diff is too big to show here.

test/quasiquote004/run.shnew file+3

This diff is too big to show here.

test/quasiquote005/Quasiquote005.idrnew file+22

This diff is too big to show here.

test/quasiquote005/expected.outnew file

No changes to the content.

test/quasiquote005/run.shnew file+3

This diff is too big to show here.

test/quasiquote006/expected.outnew file+31

This diff is too big to show here.

test/quasiquote006/quasiquote006.idrnew file+21

This diff is too big to show here.

test/quasiquote006/run.shnew file+3

This diff is too big to show here.

test/records001/expected.outnew file+5

This diff is too big to show here.

test/test011/run → test/records001/run.shrenamed+1−1

This diff is too big to show here.

test/records001/test011.idrnew file+30

This diff is too big to show here.

test/records002/expected.outnew file+2

This diff is too big to show here.

test/records002/record002.idrnew file+12

This diff is too big to show here.

test/records002/run.shnew file+4

This diff is too big to show here.

test/records003/expected.outnew file+6

This diff is too big to show here.

test/records003/records003.idrnew file+46

This diff is too big to show here.

test/records003/run.shnew file+4

This diff is too big to show here.

test/records004/expected.outnew file+3

This diff is too big to show here.

test/records004/records004.idrnew file+13

This diff is too big to show here.

test/records004/run.shnew file+4

This diff is too big to show here.

test/records005/expected.outnew file+4

This diff is too big to show here.

test/records005/records005.idrnew file+39

This diff is too big to show here.

test/records005/run.shnew file+4

This diff is too big to show here.

test/reg001/Area.idrnew file+12

This diff is too big to show here.

test/reg001/TestEx.idrnew file+31

This diff is too big to show here.

test/reg001/expected.outnew file+3

This diff is too big to show here.

test/reg001/reg001.idrdeleted−11

This diff is too big to show here.

test/reg001/rundeleted−4

This diff is too big to show here.

test/reg001/run.shnew file+4

This diff is too big to show here.

test/reg002/expected → test/reg002/expected.outrenamed

The content is the same.

test/reg002/reg002.idr → test/reg002/reg012.idrrenamed+9−7

This diff is too big to show here.

test/reg002/rundeleted−4

This diff is too big to show here.

test/reg002/run.shnew file+4

This diff is too big to show here.

test/reg003/expecteddeleted−7

This diff is too big to show here.

test/reg003/rundeleted−4

This diff is too big to show here.

test/reg004/expected → test/reg004/expected.outrenamed

The content is the same.

test/reg004/reg004.idr+1−1

This diff is too big to show here.

test/reg004/run → test/reg004/run.shrenamed+1−1

This diff is too big to show here.

test/reg005/expected.outnew file+3

This diff is too big to show here.

test/reg005/reg005.idr+6−47

This diff is too big to show here.

test/reg005/run → test/reg005/run.shrenamed+1−1

This diff is too big to show here.

test/reg006/expecteddeleted−1

This diff is too big to show here.

test/reg006/rundeleted−3

This diff is too big to show here.

test/reg007/expecteddeleted−13

This diff is too big to show here.

test/reg007/expected.outnew file+14

This diff is too big to show here.

test/reg007/rundeleted−3

This diff is too big to show here.

test/reg007/run.shnew file+3

This diff is too big to show here.

test/reg008/reg008.idrdeleted−15

This diff is too big to show here.

test/reg008/rundeleted−3

This diff is too big to show here.

test/reg009/reg009.lidrdeleted−18

This diff is too big to show here.

test/reg009/rundeleted−3

This diff is too big to show here.

test/reg010/expecteddeleted−12

This diff is too big to show here.

test/reg010/rundeleted−2

This diff is too big to show here.

test/reg011/reg011.idrdeleted−9

This diff is too big to show here.

test/reg011/rundeleted−3

This diff is too big to show here.

test/reg012/reg012.lidrdeleted−34

This diff is too big to show here.

test/reg012/rundeleted−3

This diff is too big to show here.

test/reg013/expected → test/reg013/expected.outrenamed

The content is the same.

test/reg013/reg013.idr+3−3

This diff is too big to show here.

test/reg013/run → test/reg013/run.shrenamed+1−1

This diff is too big to show here.

test/reg014/reg014.idrdeleted−12

This diff is too big to show here.

test/reg014/rundeleted−3

This diff is too big to show here.

test/reg015/reg015.idrdeleted−3

This diff is too big to show here.

test/reg015/rundeleted−3

This diff is too big to show here.

test/reg016/expected → test/reg016/expected.outrenamed

The content is the same.

test/reg016/reg016.idr+6−6

This diff is too big to show here.

test/reg016/run → test/reg016/run.shrenamed+1−1

This diff is too big to show here.

test/reg017/expecteddeleted−1

This diff is too big to show here.

test/reg017/expected.outnew file+13

This diff is too big to show here.

test/reg017/reg017.idr+3−3

This diff is too big to show here.

test/reg017/rundeleted−4

This diff is too big to show here.

test/reg017/run.shnew file+4

This diff is too big to show here.

test/reg018/expecteddeleted−4

This diff is too big to show here.

test/reg018/rundeleted−5

This diff is too big to show here.

test/reg019/reg019.idrdeleted−7

This diff is too big to show here.

test/reg019/rundeleted−3

This diff is too big to show here.

test/reg020/expected → test/reg020/expected.outrenamed

The content is the same.

test/reg020/reg020.idr+2

This diff is too big to show here.

test/reg020/run → test/reg020/run.shrenamed+1−1

This diff is too big to show here.

test/reg021/reg021.idrdeleted−22

This diff is too big to show here.

test/reg021/rundeleted−3

This diff is too big to show here.

test/reg022/reg022.idrdeleted−18

This diff is too big to show here.

test/reg022/rundeleted−3

This diff is too big to show here.

test/reg023/expecteddeleted−12

This diff is too big to show here.

test/reg023/rundeleted−3

This diff is too big to show here.

test/reg024/expected → test/reg024/expected.outrenamed

The content is the same.

test/reg024/reg024.idr+1−1

This diff is too big to show here.

test/reg024/run → test/reg024/run.shrenamed+1−1

This diff is too big to show here.

test/reg025/expected → test/reg025/expected.outrenamed

The content is the same.

test/reg025/reg025.idr+17−15

This diff is too big to show here.

test/reg025/run → test/reg025/run.shrenamed+1−1

This diff is too big to show here.

test/reg026/reg026.idrdeleted−14

This diff is too big to show here.

test/reg026/rundeleted−3

This diff is too big to show here.

test/reg027/expecteddeleted−3

This diff is too big to show here.

test/reg027/expected.outnew file+7

This diff is too big to show here.

test/reg027/reg027.idr+3−18

This diff is too big to show here.

test/reg027/reg027a.idr+2−2

This diff is too big to show here.

test/reg027/rundeleted−5

This diff is too big to show here.

test/reg027/run.shnew file+5

This diff is too big to show here.

test/reg029/Reg029Wrapper.javanew file+17

This diff is too big to show here.

test/reg029/expected.outnew file+4

This diff is too big to show here.

test/reg029/reg029.idrnew file+11

This diff is too big to show here.

test/reg029/run.shnew file+17

This diff is too big to show here.

test/reg031/expected.outnew file+1

This diff is too big to show here.

test/reg031/reg031.idrnew file+8

This diff is too big to show here.

test/reg031/run.shnew file+4

This diff is too big to show here.

test/test028/expected → test/reg032/expected.outrenamed

The content is the same.

test/test028/run → test/reg032/run.shrenamed+1−1

This diff is too big to show here.

test/test028/test028.idr → test/reg032/test028.idrrenamed+1−1

This diff is too big to show here.

test/reg039/expected.outnew file+1

This diff is too big to show here.

test/reg039/reg039.idrnew file+12

This diff is too big to show here.

test/reg039/run.shnew file+8

This diff is too big to show here.

test/reg040/expected.outnew file+1

This diff is too big to show here.

test/reg040/reg040.idrnew file+7

This diff is too big to show here.

test/reg040/run.shnew file+6

This diff is too big to show here.

test/reg041/expected.outnew file+2

This diff is too big to show here.

test/reg041/ott.idrnew file+41

This diff is too big to show here.

test/reg041/run.shnew file+5

This diff is too big to show here.

test/reg041/showu.idrnew file+23

This diff is too big to show here.

test/reg042/expected.outnew file+1

This diff is too big to show here.

test/reg042/reg042.idrnew file+24

This diff is too big to show here.

test/reg042/run.shnew file+4

This diff is too big to show here.

test/reg045/expected.outnew file+1

This diff is too big to show here.

test/reg045/reg045.idrnew file+19

This diff is too big to show here.

test/reg045/run.shnew file+4

This diff is too big to show here.

test/reg048/expected.outnew file

No changes to the content.

test/reg048/reg048.idrnew file+24

This diff is too big to show here.

test/reg048/run.shnew file+4

This diff is too big to show here.

test/reg051-disabled/expected.outnew file

No changes to the content.

test/reg051-disabled/reg051.idrnew file+99

This diff is too big to show here.

test/reg051-disabled/run.shnew file+3

This diff is too big to show here.

test/reg052/expected.outnew file+1

This diff is too big to show here.

test/reg052/reg052.idrnew file+8

This diff is too big to show here.

test/reg052/run.shnew file+4

This diff is too big to show here.

test/reg067/expected.outnew file+1

This diff is too big to show here.

test/reg067/reg067.idrnew file+23

This diff is too big to show here.

test/reg067/run.shnew file+5

This diff is too big to show here.

test/reg075/expected.outnew file+6

This diff is too big to show here.

test/reg075/input.innew file+1

This diff is too big to show here.

test/reg075/reg075.idrnew file+33

This diff is too big to show here.

test/reg075/run.shnew file+3

This diff is too big to show here.

test/reg076/expected.outnew file+1

This diff is too big to show here.

test/reg076/input.innew file

No changes to the content.

test/reg076/reg076.idrnew file+11

This diff is too big to show here.

test/reg076/run.shnew file+4

This diff is too big to show here.

test/reg077/expected.outnew file

No changes to the content.

test/reg077/reg077.idrnew file+17

This diff is too big to show here.

test/reg077/run.shnew file+3

This diff is too big to show here.

test/regression001/coverage001.idrnew file+79

This diff is too big to show here.

test/regression001/eff001.idrnew file+39

This diff is too big to show here.

test/regression001/expected.outnew file

No changes to the content.

test/regression001/reg001.idrnew file+209

This diff is too big to show here.

test/regression001/reg002.idrnew file+8

This diff is too big to show here.

test/regression001/reg003.idrnew file+11

This diff is too big to show here.

test/regression001/reg004.lidrnew file+43

This diff is too big to show here.

test/regression001/reg005.idrnew file+8

This diff is too big to show here.

test/regression001/reg006.idrnew file+14

This diff is too big to show here.

test/regression001/reg007.idrnew file+69

This diff is too big to show here.

test/regression001/reg036.idrnew file+12

This diff is too big to show here.

test/regression001/reg037.idrnew file+9

This diff is too big to show here.

test/regression001/reg038.idrnew file+17

This diff is too big to show here.

test/regression001/reg046.idrnew file+19

This diff is too big to show here.

test/regression001/reg047.idrnew file+18

This diff is too big to show here.

test/regression001/reg047a.idrnew file+24

This diff is too big to show here.

test/regression001/reg053.idrnew file+9

This diff is too big to show here.

test/regression001/reg057.idrnew file+8

This diff is too big to show here.

test/regression001/reg058.idrnew file+14

This diff is too big to show here.

test/regression001/reg058a.idrnew file+19

This diff is too big to show here.

test/regression001/reg059.idrnew file+8

This diff is too big to show here.

test/regression001/reg060.idrnew file+12

This diff is too big to show here.

test/regression001/reg061.idrnew file+9

This diff is too big to show here.

test/regression001/reg062.idrnew file+13

This diff is too big to show here.

test/regression001/reg063.idrnew file+19

This diff is too big to show here.

test/regression001/reg064.idrnew file+8

This diff is too big to show here.

test/regression001/reg065.idrnew file+26

This diff is too big to show here.

test/regression001/reg066.idrnew file+7

This diff is too big to show here.

test/regression001/reg071.idrnew file+19

This diff is too big to show here.

test/regression001/reg073.lidrnew file+24

This diff is too big to show here.

test/regression001/reg074.idrnew file+21

This diff is too big to show here.

test/regression001/run.shnew file+18

This diff is too big to show here.

test/reg007/A.lidr → test/regression002/A.lidrrenamed+1−1

This diff is too big to show here.

test/regression002/Canonicity.idrnew file+13

This diff is too big to show here.

test/regression002/DoubleEquality.idrnew file+5

This diff is too big to show here.

test/regression002/Mod.idrnew file+12

This diff is too big to show here.

test/regression002/Negation.idrnew file+2

This diff is too big to show here.

test/regression002/badbangop.idrnew file+15

This diff is too big to show here.

test/regression002/baddoublebang.idrnew file+7

This diff is too big to show here.

test/regression002/expected.outnew file+368

This diff is too big to show here.

test/regression002/reg001.idrnew file+2

This diff is too big to show here.

test/regression002/reg002.idrnew file+3

This diff is too big to show here.

test/reg003/reg003.idr → test/regression002/reg003.idrrenamed

The content is the same.

test/reg003/reg003a.idr → test/regression002/reg003a.idrrenamed

The content is the same.

test/reg006/reg006.idr → test/regression002/reg006.idrrenamed+6−5

This diff is too big to show here.

test/reg007/reg007.lidr → test/regression002/reg007.lidrrenamed+1−1

This diff is too big to show here.

test/reg010/reg010.idr → test/regression002/reg010.idrrenamed

The content is the same.

test/reg018/reg018a.idr → test/regression002/reg018a.idrrenamed

The content is the same.

test/reg018/reg018b.idr → test/regression002/reg018b.idrrenamed+1−1

This diff is too big to show here.

test/reg018/reg018c.idr → test/regression002/reg018c.idrrenamed+3−1

This diff is too big to show here.

test/reg018/reg018d.idr → test/regression002/reg018d.idrrenamed+6−3

This diff is too big to show here.

test/reg023/reg023.idr → test/regression002/reg023.idrrenamed

The content is the same.

test/regression002/reg028.idrnew file+8

This diff is too big to show here.

test/regression002/reg028a.idrnew file+25

This diff is too big to show here.

test/regression002/reg034.idrnew file+10

This diff is too big to show here.

test/regression002/reg035.idrnew file+15

This diff is too big to show here.

test/regression002/reg035a.lidrnew file+67

This diff is too big to show here.

test/regression002/reg035b.idrnew file+12

This diff is too big to show here.

test/regression002/reg044.idrnew file+6

This diff is too big to show here.

test/regression002/reg049.idrnew file+5

This diff is too big to show here.

test/regression002/reg054.idrnew file+42

This diff is too big to show here.

test/regression002/reg055.idrnew file+26

This diff is too big to show here.

test/regression002/reg055a.idrnew file+15

This diff is too big to show here.

test/regression002/reg056.idrnew file+14

This diff is too big to show here.

test/regression002/reg068.idrnew file+4

This diff is too big to show here.

test/regression002/reg069.idrnew file+5

This diff is too big to show here.

test/regression002/reg070.idrnew file+15

This diff is too big to show here.

test/regression002/reg076.idrnew file+7

This diff is too big to show here.

test/regression002/reg077.idrnew file+2

This diff is too big to show here.

test/regression002/run.shnew file+41

This diff is too big to show here.

test/regression002/working.idrnew file+21

This diff is too big to show here.

test/regression003/expected.outnew file+1

This diff is too big to show here.

test/regression003/regression003.idrnew file+56

This diff is too big to show here.

test/regression003/run.shnew file+4

This diff is too big to show here.

test/runtest.pldeleted−112

This diff is too big to show here.

test/scripts/timeoutnew file+17

This diff is too big to show here.

test/sourceLocation001/SourceLoc.idrnew file+103

This diff is too big to show here.

test/sourceLocation001/expected.outnew file+35

This diff is too big to show here.

test/sourceLocation001/run.shnew file+4

This diff is too big to show here.

test/st001/expected.outnew file+8

This diff is too big to show here.

test/st001/run.shnew file+6

This diff is too big to show here.

test/st001/test001.idrnew file+66

This diff is too big to show here.

test/st001/testFile.innew file+2

This diff is too big to show here.

test/st002/expected.outnew file+8

This diff is too big to show here.

test/st002/run.shnew file+6

This diff is too big to show here.

test/st002/test002.idrnew file+66

This diff is too big to show here.

test/st002/testFile.innew file+2

This diff is too big to show here.

test/st003/expected.outnew file+8

This diff is too big to show here.

test/st003/run.shnew file+6

This diff is too big to show here.

test/st003/test003.idrnew file+25

This diff is too big to show here.

test/st003/testFile.innew file+2

This diff is too big to show here.

test/st004/expected.outnew file+6

This diff is too big to show here.

test/st004/run.shnew file+6

This diff is too big to show here.

test/st004/test004.idrnew file+24

This diff is too big to show here.

test/st005/expected.outnew file+6

This diff is too big to show here.

test/st005/run.shnew file+7

This diff is too big to show here.

test/st005/test005.idrnew file+33

This diff is too big to show here.

test/st006/expected.outnew file+5

This diff is too big to show here.

test/st006/run.shnew file+6

This diff is too big to show here.

test/st006/test006.idrnew file+37

This diff is too big to show here.

test/st007/expected.outnew file+6

This diff is too big to show here.

test/st007/run.shnew file+6

This diff is too big to show here.

test/st007/test007.idrnew file+24

This diff is too big to show here.

test/test007/expected → test/sugar001/expected.outrenamed

The content is the same.

test/test007/run → test/sugar001/run.shrenamed+1−1

This diff is too big to show here.

test/test007/test007.idr → test/sugar001/test007.idrrenamed+7−7

This diff is too big to show here.

test/test009/expected → test/sugar002/expected.outrenamed

The content is the same.

test/test009/run → test/sugar002/run.shrenamed+1−1

This diff is too big to show here.

test/test009/test009.idr → test/sugar002/test009.idrrenamed

The content is the same.

test/test013/expected → test/sugar003/expected.outrenamed

The content is the same.

test/test013/run → test/sugar003/run.shrenamed+1−1

This diff is too big to show here.

test/test013/test013.idr → test/sugar003/test013.idrrenamed+1−1

This diff is too big to show here.

test/sugar004/expected.outnew file+4

This diff is too big to show here.

test/sugar004/run.shnew file+7

This diff is too big to show here.

test/sugar004/sugar004.idrnew file+47

This diff is too big to show here.

test/sugar005/As.idrnew file+36

This diff is too big to show here.

test/sugar005/expected.outnew file+9

This diff is too big to show here.

test/sugar005/run.shnew file+4

This diff is too big to show here.

test/syntax001/Syntax.idrnew file+8

This diff is too big to show here.

test/syntax001/SyntaxOk.idrnew file+6

This diff is too big to show here.

test/syntax001/SyntaxTest.idrnew file+5

This diff is too big to show here.

test/syntax001/expected.outnew file+26

This diff is too big to show here.

test/syntax001/run.shnew file+4

This diff is too big to show here.

test/syntax002/expected.outnew file+2

This diff is too big to show here.

test/syntax002/run.shnew file+4

This diff is too big to show here.

test/syntax002/syntax002.idrnew file+22

This diff is too big to show here.

test/tactics001/Tactics.idrnew file+43

This diff is too big to show here.

test/tactics001/expected.outnew file

No changes to the content.

test/tactics001/run.shnew file+3

This diff is too big to show here.

test/test001/expecteddeleted−2

This diff is too big to show here.

test/test001/rundeleted−4

This diff is too big to show here.

test/test002/expecteddeleted−1

This diff is too big to show here.

test/test002/rundeleted−3

This diff is too big to show here.

test/test003/expecteddeleted−7

This diff is too big to show here.

test/test003/rundeleted−5

This diff is too big to show here.

test/test005/expecteddeleted−6

This diff is too big to show here.

test/test005/rundeleted−4

This diff is too big to show here.

test/test005/test005.idrdeleted−15

This diff is too big to show here.

test/test006/expecteddeleted−1

This diff is too big to show here.

test/test010/expecteddeleted−3

This diff is too big to show here.

test/test010/rundeleted−6

This diff is too big to show here.

test/test011/expecteddeleted−5

This diff is too big to show here.

test/test011/test011.idrdeleted−26

This diff is too big to show here.

test/test012/expecteddeleted−1

This diff is too big to show here.

test/test012/rundeleted−2

This diff is too big to show here.

test/test012/test012a.idrdeleted−10

This diff is too big to show here.

test/test014/rundeleted−4

This diff is too big to show here.

test/test015/expecteddeleted−3

This diff is too big to show here.

test/test015/rundeleted−4

This diff is too big to show here.

test/test017/expecteddeleted−2

This diff is too big to show here.

test/test017/rundeleted−5

This diff is too big to show here.

test/test018/rundeleted−6

This diff is too big to show here.

test/test019/test019.lidrdeleted−16

This diff is too big to show here.

test/test020/expecteddeleted−14

This diff is too big to show here.

test/test020/rundeleted−5

This diff is too big to show here.

test/test021/expecteddeleted−6

This diff is too big to show here.

test/test021/rundeleted−6

This diff is too big to show here.

test/test021/test021.idrdeleted−35

This diff is too big to show here.

test/test022/expecteddeleted−2

This diff is too big to show here.

test/test022/rundeleted−3

This diff is too big to show here.

test/test022/test022.idrdeleted−6

This diff is too big to show here.

test/test023/expecteddeleted−1

This diff is too big to show here.

test/test023/rundeleted−3

This diff is too big to show here.

test/test024/expecteddeleted−3

This diff is too big to show here.

test/test024/inputdeleted−2

This diff is too big to show here.

test/test024/rundeleted−3

This diff is too big to show here.

test/test025/rundeleted−4

This diff is too big to show here.

test/test025/test025.idrdeleted−34

This diff is too big to show here.

test/test026/expecteddeleted−3

This diff is too big to show here.

test/test026/inputdeleted−2

This diff is too big to show here.

test/test026/rundeleted−3

This diff is too big to show here.

test/test026/theOtherTypedeleted−1

This diff is too big to show here.

test/test029/rundeleted−3

This diff is too big to show here.

test/test030/expecteddeleted−12

This diff is too big to show here.

test/test030/rundeleted−4

This diff is too big to show here.

test/test032/expecteddeleted−11

This diff is too big to show here.

test/test032/inputdeleted−5

This diff is too big to show here.

test/test032/rundeleted−3

This diff is too big to show here.

test/test033/test033.idrdeleted−4

This diff is too big to show here.

test/test034/rundeleted−49

This diff is too big to show here.

test/totality001/expected.outnew file+18

This diff is too big to show here.

test/totality001/run.shnew file+6

This diff is too big to show here.

test/test010/test010.idr → test/totality001/test010.idrrenamed+2

This diff is too big to show here.

test/test010/test010a.idr → test/totality001/test010a.idrrenamed

The content is the same.

test/test010/test010b.idr → test/totality001/test010b.idrrenamed

The content is the same.

test/totality002/expected.outnew file+18

This diff is too big to show here.

test/totality002/run.shnew file+5

This diff is too big to show here.

test/test017/test017.idr → test/totality002/test017.idrrenamed+22−18

This diff is too big to show here.

test/test017/test017a.idr → test/totality002/test017a.idrrenamed+2

This diff is too big to show here.

test/test017/test017b.idr → test/totality002/test017b.idrrenamed+1−1

This diff is too big to show here.

test/totality003/expected.outnew file+6

This diff is too big to show here.

test/totality003/run.shnew file+4

This diff is too big to show here.

test/totality003/totality003.idrnew file+7

This diff is too big to show here.

test/totality003/totality003a.idrnew file+7

This diff is too big to show here.

test/totality004/expected.outnew file+13

This diff is too big to show here.

test/totality004/run.shnew file+5

This diff is too big to show here.

test/totality004/totality004.idrnew file+25

This diff is too big to show here.

test/totality004/totality004a.idrnew file+24

This diff is too big to show here.

test/totality005/expected.outnew file+1

This diff is too big to show here.

test/totality005/run.shnew file+5

This diff is too big to show here.

test/totality005/totality005.idrnew file+10

This diff is too big to show here.

test/totality006/expected.outnew file+18

This diff is too big to show here.

test/totality006/run.shnew file+5

This diff is too big to show here.

test/totality006/totality006.idrnew file+13

This diff is too big to show here.

test/totality006/totality006a.idrnew file+12

This diff is too big to show here.

test/totality006/totality006b.idrnew file+14

This diff is too big to show here.

test/totality007/expected.msysnew file+5

This diff is too big to show here.

test/totality007/expected.outnew file+9

This diff is too big to show here.

test/totality007/run.shnew file+3

This diff is too big to show here.

test/totality007/src/Totality.idrnew file+4

This diff is too big to show here.

test/totality007/totality.ipkgnew file+7

This diff is too big to show here.

test/totality008/expected.outnew file+6

This diff is too big to show here.

test/totality008/run.shnew file+3

This diff is too big to show here.

test/totality008/totality008.idrnew file+8

This diff is too big to show here.

test/totality009/TestLambdaImpossible.idrnew file+26

This diff is too big to show here.

test/totality009/TestLambdaPossible.idrnew file+14

This diff is too big to show here.

test/totality009/TestLambdaPossible2.idrnew file+16

This diff is too big to show here.

test/totality009/expected.outnew file+60

This diff is too big to show here.

test/totality009/run.shnew file+6

This diff is too big to show here.

test/totality010/expected.outnew file+12

This diff is too big to show here.

test/totality010/run.shnew file+3

This diff is too big to show here.

test/totality010/totality010.idrnew file+31

This diff is too big to show here.

test/totality011/expected.outnew file+6

This diff is too big to show here.

test/totality011/run.shnew file+3

This diff is too big to show here.

test/totality011/totality011.lidrnew file+31

This diff is too big to show here.

test/totality012/expected.outnew file+12

This diff is too big to show here.

test/totality012/run.shnew file+5

This diff is too big to show here.

test/totality012/totality012.idrnew file+30

This diff is too big to show here.

test/totality012/totality012a.idrnew file+12

This diff is too big to show here.

test/totality012/totality012b.idrnew file+18

This diff is too big to show here.

test/totality013/expected.outnew file+12

This diff is too big to show here.

test/totality013/run.shnew file+4

This diff is too big to show here.

test/totality013/totality013.idrnew file+16

This diff is too big to show here.

test/totality013/totality013a.idrnew file+17

This diff is too big to show here.

test/totality014/expected.outnew file+13

This diff is too big to show here.

test/totality014/run.shnew file+3

This diff is too big to show here.

test/totality014/totality014.idrnew file+7

This diff is too big to show here.

test/totality015/expected.outnew file+18

This diff is too big to show here.

test/totality015/run.shnew file+4

This diff is too big to show here.

test/totality015/totality015.idrnew file+70

This diff is too big to show here.

test/totality015/totality015a.idrnew file+63

This diff is too big to show here.

test/totality016/expected.outnew file+54

This diff is too big to show here.

test/totality016/run.shnew file+3

This diff is too big to show here.

test/totality016/totality016.idrnew file+48

This diff is too big to show here.

test/totality017/expected.outnew file+36

This diff is too big to show here.

test/totality017/run.shnew file+3

This diff is too big to show here.

test/totality017/totality017.idrnew file+49

This diff is too big to show here.

test/totality018/expected.outnew file+6

This diff is too big to show here.

test/totality018/run.shnew file+3

This diff is too big to show here.

test/totality018/totality018.idrnew file+15

This diff is too big to show here.

test/totality019/expected.outnew file+12

This diff is too big to show here.

test/totality019/run.shnew file+4

This diff is too big to show here.

test/totality019/totality019.idrnew file+14

This diff is too big to show here.

test/totality019/totality019a.idrnew file+81

This diff is too big to show here.

test/totality020/expected.outnew file+12

This diff is too big to show here.

test/totality020/run.shnew file+3

This diff is too big to show here.

test/totality020/totality020.idrnew file+11

This diff is too big to show here.

test/totality021/expected.outnew file+30

This diff is too big to show here.

test/totality021/run.shnew file+4

This diff is too big to show here.

test/totality021/totality021.idrnew file+18

This diff is too big to show here.

test/totality021/totality021a.idrnew file+12

This diff is too big to show here.

test/totality022/expected.outnew file+6

This diff is too big to show here.

test/totality022/run.shnew file+3

This diff is too big to show here.

test/totality022/totality022.idrnew file+11

This diff is too big to show here.

test/totality023/expected.outnew file+6

This diff is too big to show here.

test/totality023/run.shnew file+3

This diff is too big to show here.

test/totality023/totality023.idrnew file+11

This diff is too big to show here.

test/totality024/expected.outnew file+1

This diff is too big to show here.

test/totality024/run.shnew file+3

This diff is too big to show here.

test/totality024/totality023.idrnew file+7

This diff is too big to show here.

test/totality025/expected.outnew file+18

This diff is too big to show here.

test/totality025/run.shnew file+3

This diff is too big to show here.

test/totality025/totality025.idrnew file+17

This diff is too big to show here.

test/totality026/expected.outnew file+6

This diff is too big to show here.

test/totality026/run.shnew file+3

This diff is too big to show here.

test/totality026/totality026.idrnew file+7

This diff is too big to show here.

test/tutorial001/expected.outnew file

No changes to the content.

test/tutorial001/run.shnew file+3

This diff is too big to show here.

test/tutorial001/tutorial001.idrnew file+9

This diff is too big to show here.

test/tutorial002/expected.outnew file+18

This diff is too big to show here.

test/tutorial002/run.shnew file+3

This diff is too big to show here.

test/tutorial002/tutorial002.idrnew file+61

This diff is too big to show here.

test/tutorial003/expected.outnew file

No changes to the content.

test/tutorial003/run.shnew file+3

This diff is too big to show here.

tutorial/examples/idiom.idr → test/tutorial003/tutorial003.idrrenamed+3−3

This diff is too big to show here.

test/tutorial004/expected.outnew file+12

This diff is too big to show here.

test/tutorial004/run.shnew file+3

This diff is too big to show here.

tutorial/examples/theorems.idr → test/tutorial004/tutorial004.idrrenamed+10−10

This diff is too big to show here.

test/tutorial005/expected.outnew file

No changes to the content.

test/tutorial005/run.shnew file+3

This diff is too big to show here.

tutorial/examples/wheres.idr → test/tutorial005/tutorial005.idrrenamed

The content is the same.

test/tutorial006/expected.outnew file+37

This diff is too big to show here.

test/tutorial006/run.shnew file+5

This diff is too big to show here.

tutorial/examples/vbroken.idr → test/tutorial006/tutorial006a.idrrenamed+2

This diff is too big to show here.

test/tutorial006/tutorial006b.idrnew file+12

This diff is too big to show here.

test/tutorial006/tutorial006c.idrnew file+20

This diff is too big to show here.

test/tutorial007/Providers.idrnew file+27

This diff is too big to show here.

test/tutorial007/expected.outnew file+1

This diff is too big to show here.

test/tutorial007/nativetypes.cnew file+13

This diff is too big to show here.

test/tutorial007/run.shnew file+5

This diff is too big to show here.

test/tutorial007/tutorial007.idrnew file+12

This diff is too big to show here.

test/unique001/expected.outnew file+4

This diff is too big to show here.

test/unique001/run.shnew file+6

This diff is too big to show here.

test/unique001/unique001.idrnew file+34

This diff is too big to show here.

test/unique004/expected.outnew file+75

This diff is too big to show here.

test/unique004/run.shnew file+14

This diff is too big to show here.

test/unique004/unique001a.idrnew file+64

This diff is too big to show here.

test/unique004/unique001b.idrnew file+32

This diff is too big to show here.

test/unique004/unique001c.idrnew file+47

This diff is too big to show here.

test/unique004/unique001d.idrnew file+4

This diff is too big to show here.

test/unique004/unique001e.idrnew file+5

This diff is too big to show here.

test/unique004/unique002.idrnew file+22

This diff is too big to show here.

test/unique004/unique002a.idrnew file+20

This diff is too big to show here.

test/unique004/unique003.idrnew file+24

This diff is too big to show here.

test/universes001/expected.outnew file+14

This diff is too big to show here.

test/universes001/run.shnew file+3

This diff is too big to show here.

test/universes001/universes001.idrnew file+8

This diff is too big to show here.

test/universes002/expected.outnew file+14

This diff is too big to show here.

test/universes002/run.shnew file+3

This diff is too big to show here.

test/universes002/universes002.idrnew file+45

This diff is too big to show here.

test/views001/expected.outnew file+5

This diff is too big to show here.

test/views001/run.shnew file+6

This diff is too big to show here.

test/views001/views001.idrnew file+43

This diff is too big to show here.

test/views001/views001a.idrnew file+29

This diff is too big to show here.

test/views002/expected.outnew file+2

This diff is too big to show here.

test/views002/run.shnew file+4

This diff is too big to show here.

test/views002/views002.idrnew file+26

This diff is too big to show here.

test/views003/expected.outnew file+1

This diff is too big to show here.

test/views003/run.shnew file+4

This diff is too big to show here.

test/views003/views003.idrnew file+31

This diff is too big to show here.

tutorial/Makefiledeleted−40

This diff is too big to show here.

tutorial/conf.ltxdeleted−17

This diff is too big to show here.

tutorial/content/classes.texdeleted−440

This diff is too big to show here.

tutorial/content/conclusions.texdeleted−14

This diff is too big to show here.

tutorial/content/dsl.texdeleted−82

This diff is too big to show here.

tutorial/content/interp.texdeleted−332

This diff is too big to show here.

tutorial/content/intro.texdeleted−65

This diff is too big to show here.

tutorial/content/miscellany.texdeleted−458

This diff is too big to show here.

tutorial/content/modules.texdeleted−201

This diff is too big to show here.

tutorial/content/provisional.texdeleted−284

This diff is too big to show here.

tutorial/content/starting.texdeleted−145

This diff is too big to show here.

tutorial/content/syntax.texdeleted−104

This diff is too big to show here.

tutorial/content/theorems.texdeleted−377

This diff is too big to show here.

tutorial/content/typesfuns.texdeleted−1017

This diff is too big to show here.

tutorial/content/views.texdeleted−96

This diff is too big to show here.

tutorial/examples/binary.idrdeleted−62

This diff is too big to show here.

tutorial/examples/views.idrdeleted−37

This diff is too big to show here.

tutorial/fpmacros.stydeleted−1086

This diff is too big to show here.

tutorial/idris-tutorial.texdeleted−56

This diff is too big to show here.

tutorial/idrislang.stydeleted−190

This diff is too big to show here.

tutorial/library.ltxdeleted−325

This diff is too big to show here.

tutorial/literature.bibdeleted−3856

This diff is too big to show here.

win-release.shnew file+2

This diff is too big to show here.