Create a development environment for dependent type theories

Implement a dependent type system

Derive the constant map

Implement a new type system

Update version

Cleanup

Make differentiable functions partially applicable

Cleanup and document

Remove unused array types

Train a model on MNIST

Automake

Download and load the MNIST dataset

Add a copyright and license notice in each file

Implement reverse mode automatic differentiation

Catch offending generated input(s) on error

Optimize garbage collection

Instead of allocating memory on every index of every
differentiable function call we do it once per call
and use the buffer for all indices.

Allow reset of evaluated promises

Copy srfi-45.scm from guile-3.0.9.120-79e83-dirty/module/srfi/

Optimize `contract-arrays' using absolute indexing

Correct cos'

Precompute values for jacobian generators

Add more differentiable functions

Take instead of reverse drop

Change generic for typed and unspecified arrays

Optimize the gradient algorithm

With this optimization the jacobians are computed column by
column improving both space and time complexity.

Test gradient of `amap2' on non-internal inputs but internal result

Implement a functional flip

Implement an automatic differentiation engine

Add utilities useful for working with arrays

Cleanup and add some docstrings

Define `flip' and `char=?'

Bootstrap the system

Fix issues with (vdc base) and add reversed composition

- Call guile's 1+ instead of itself
- Curry internal applications of higher order functions
- Declare types at both expansion and compilation time

Compare function types with TBD types

Modularize types

Define a language to use curried functions in the REPL

Copy files from guile-3.0.9.22-1ae50-dirty/module/language/scheme/

Curry some procedures from (rnrs base) and (srfi srfi-1)

Declare the type at macro expansion time

Implement typed curried definitions

Expand partial applications when needed

Play nicer with regular Scheme

Change argument counting to type construction

Instead of counting the arguments a function can receive
we now construct its type. Anything but functions has
a type of 0 while (curried) functions are typed with cons
cells containing the type of its domain and codomain.

Test flipped function composition

Fix currying of higher order functions

Expand curried functions and check for errors

Add license