package gobba

  1. Overview
  2. Docs
A simple, didactical, purely functional programming language

Install

Dune Dependency

Authors

Maintainers

Sources

0.4.2.tar.gz
md5=ebd91da495014a6d0a34de40245ab5a6
sha512=7a5875fff15e8997d9c2db6c3a898c15f9ce144c5b4fce1d57f0c6127eb63d6780458e2fe5e90048fa81ceadd67676de4ccfc3723b2c5fbfe528d68c3b91d842

CHANGES.md.html

0.4.2 2020-11-28

Added

  • Updated libraries. Minor fixes.

  • The REPL now has readline features by default (without the readline dependency) and more!

  • REPL tab completion and hints.

  • Optimized the primitive call abstraction

  • Separated primitives in their appropriate modules

  • Fixed size vectors and characters

  • A lot of improvements in the stdlib primitives.

  • A cute mascotte called gamel

Fixes

  • Complex number parsing, allocation and arithmetics

  • Operator precedence

0.4.1 2020-01-17

  • Renamed project from minicaml to gobba!

  • Syntax is now more haskel-ly: use , to separate list and dictionary values, use >> to sequence operations (bind) and use ; to end statements.

  • Improved purity inference algorithm with correct module inference

  • Some minor improvements

0.4 2020-01-16

  • Multiline REPL

  • New dictionary syntax

  • Static purity inference algorithm

  • map, foldl and foldr are implemented in the language

  • Integer division now returns a float if the modulo between the two numbers is 0

  • Print the type in the REPL result

  • Directives on the toplevel: #include filename and #import to load and run files, #verbose n to set a verbosity level, #pure, #impure and #uncertain to set the global purity context.

  • Gobba and OCaml Stack traces on errors!

  • Removed the let rec and let rec lazy statements.

  • lazy-ness is now meant for each single assignment in a let statement, and they can be mixed; This is now valid: let a = ... and lazy b = ... ;;

  • A LOT of internal optimizations.

  • Lambda and Closure abstractions for function now have a single parameter and can be nested. This means that (fun x y z -> ...) = (fun x -> (fun y -> (fun z -> ...))) is now true, and the evaluation gets quite simplified (for example, in partial evaluation)

  • Composition and reverse composition are back and working with <=< and >=>

  • Purity inference is now done before evaluation

  • Capability of recursion is now inferred automatically basing on the location of a fun expression.

0.3.3 2020-01-08

  • Rely on the Ramda.js library for JS transpilation. (Currently broken because of numerical primitives and a lack of a Complex number solution for Javascript).

  • Full numerical tower comprising Integer (Natural) numbers, Floating Point (Real) numbers and Complex numbers, with dynamic number-type infering arithmetical primitives.

  • Switch between pure and impure primitives.

  • Simple I/O primitives for printing.

  • More examples and features descriptions in the README file.

0.3.2 2019-01-03

Added

  • Reworking of language internals.

  • Fixed build process

  • More primitives and operators.

  • AST optimizations based on propositional calculus laws.

  • Experimental Javascript transpiler! :)

0.3.1 2019-12-26

Added

  • map2 primitive

  • Reading programs from files

  • An abstraction that allows treating primitives as functions, and so allows currying and all the fancy stuff.

  • Examples in the examples/ directory

  • Greater or equal to and Less than or equal to operators

  • More test coverage.

Bugfixes

  • Fixed various bugs of 0.3

0.3 2019-12-25

Added

  • A simple AST optimizer

  • Multiple let assignments (let x = 2 and y = 3 and z = ... in ...)

  • Function currying (partial application)

  • Strings

  • Sequences of expressions separated with ; are treated as a single expression that returns the value of the last one.

  • Function pipelining (reverse composition) with the >=> operator. ((fun x y -> x + y >=> g) 1 2 is g 3)

  • Dictionaries ({"hello": 123, "world": 345})

  • Map, foldl and filter on lists and dictionaries

  • Testing and code coverage using alcotest and bisect_ppx

Bugfixes

  • Fixed function application parser

0.2.2 2019-12-13

Added

  • let lazy rec (or let rec lazy) to define recursive lazy functions

  • Command line option parser and man page

  • Command line option -v (--verbose) to tell the REPL to show the AST and reduction steps.

  • Evaluation step printing is now done in correct order and nesting.

Bugfixes

  • Fixed boolean primitives.

Removed

  • lazyfun and lazylambda statements.

0.2.1 2019-12-12

Added

  • Optional lazy evaluation! You can use let lazy to define values that will be evaluated only when encountered in the let lazy expression body.

  • Lazy anonymous functions! Just like the let lazy statement you can now use lazyfun or lazylambda to define anonymous functions which arguments will be lazily evaluated.

Bugfixes

  • Fixed precedence levels in parser

Roadmap

  • Cache for lazy evaluation

  • Partial application

0.2 2019-12-08

Added

  • Lists

  • Unit

0.1 2019-12-03

Added

  • Initial release of the project

OCaml

Innovation. Community. Security.