cloe-lang / cloe

Cloe programming language

Cloe

Cloe is the timeless functional programming language. It aims to be simple and practical.

Features

• Functional programming
• Immutable data
• Lazy evaluation
• Implicit parallelism, concurrency, and reactivity

Installation

go get -u github.com/cloe-lang/cloe/...

Go 1.8+ is required.

Documentation

Here.

Examples

Hello, world!

(print "Hello, world!")

HTTP server

(import "http")

(def (handler request)
  ((@ request "respond") "Hello, world!"))

(let requests (http.getRequests ":8080"))

..(map handler requests)

See examples directory for more.

License

MIT

cloe's Issues

Match expression

Pattern match as macros. No design of it so far. It would look like ones in other languages like Haskell and OCaml.

(let x (match matchedValue
    PATTERN1 expression1
    PATTERN2 expression2))

Mascot

We need a kawaii mascot. OCaml Haskell?

Implement par function

Support par primitive function like Glasgow Parallel Haskell. It enables us to increase parallelisms of programs and make impure functions run asynchronously.

References

• Par and seq - HaskellWiki

Collection interface

Renew ordered interface

Rename ordered interface as comparable and create a totally new ordered interface and implement it for string, number, and list types.

interface ordered {
    ordered() // Just mark as an ordered type.
}

Fix nested functions with duplicate arguments

(let (f x y)
  (let (g x) (+ 1 x))
  (g y))

(write (f 3 5)) ; => 6

Catch panics from less function in rbt.Tree's methods

Fix handling of wildcard patterns

regex library

Should support regex library. We may utilize Go's regexp library or some third-party's.

HTTP library

HTTP library support in the language. One naive design consists of 2 basic functions. One creates HTTP requests as an infinite list and the other one sends responses. This can have more priority than the socket library.

Prefer codebeat to code climate?

good?

Move test/features directory to examples directory

Kahn Process Networks

The way the "Time is space" principle is documented (programs as functions from a stream of inputs to a stream of outputs) makes it spectacularly similar to the Kahn Process Networks model of computation and programming.

Several programming languages for "reactive programming" has been inspired by Kahn Networks, in particular Lustre and Lucid Synchrone. There have also been work on efficient runtime for this form of parallelism, based on efficient implementations of concurrent FIFO queues.

I think it would be interesting for the authors of Tisp looking at these languages to see if there are ideas to take inspiration from.

Add anonymous function syntax

Macro system

We may not support reader macros.

(macro (unless cond then else) `(if ~cond ~else ~then))

(macro (foo) `123)
(write (+ (foo) bar))

Delete function for Dictionary, Set, and List

Implement del function for Dictionary, Set, and List types.
Documented here.

inspired in lisp?

The syntax reminds me of Lisp

Error handling in Thunk.Eval()

Handle Errors automatically in Thunk.Eval().
Thunk.EvalOrReturnError() may be needed for manual error handling.
We may need to store function names in vm.FunctionType and vm.ClosureType to trace function calls.

Handle rest wildcard patterns of list and dictionary types

Create util.UserError

Create typeOf function

(typeOf 123) ; => "number"
(typeOf "foo") ; => "string"
(typeOf []) ; => "list"
(typeOf {}) ; => "dict"
(typeOf true) ; => "bool"
(typeOf nil) ; => "nil"
(typeOf someError) ; => "error"

Add a way to catch errors

Maybe a special function. Some code in thunk.go may need to be changed.

Unify LetVar and LetFunction into Let

Optional injection of parallelism

Support par primitive function like Glasgow Parallel Haskell. It enables us to increase parallelisms of programs and make impure functions run asynchronously.

Test ticket from Code Climate

Nested let statements for let-variable statements

We may support nested let statements for let-variable statements. If it's preferred, reopen this issue.

Create stdlib package

Create stdlib package for standard library of Tisp.
Some functions in it would be builtins.

Fully featured write function

Add file option.

Module system

import as just an another special form.

(import "directory/module_name") ; statically used by compiler
(write (module_name.calcAnswer 42))

mr

Implement mr.

s/cause/seq/g

Use systemt.Daemonize() in NewStrictFunction() and List.ToValues()

To prevent some kind of memory leak caused by recursive functions.
Or, delete NewStrictFunction() and use Par?

Create OutputType

OutputType is used only internally to represent outputs from impure functions. Every output function should return OutputType. They are ignored by top-level calls of Thunk.Eval() and seq primitive function.

s/ArgumentSet/HalfSignature/g

Comparison operators

<, >, =, <=, >= for Number, String, and List types. = has been implemented already.

Set data structure

Implement set data structures as core.SetType.

Indexing as function calls

Like NewLisp implementing vm.callable for vm.ListType and vm.DictionaryType.

(= ([1 2 3] 1) 2)
(= ([1 2 3] 0 1) [1 2])

(= ({"foo" 123} "foo") 123) 

Str function

Implement str function which converts values of built-in types into their string representations.
And use it in write function.

docstring in let statements

Examples are here. Values of docstrings should be able to be extracted from functions at runtime.

s/vm/core/g

I think it's not a VM.

Create NewMatchFunction function in core

Recursive let-function

Replace util.Fail() to panic()

read function

socket library

Socket library support in the language.

Create indexOf function for lists (or all collections)

Like Python's [1, 3, 5, 7].index(5) == 2.

gensym package

rally function

rally function takes values and returns a list containing them but they are sorted by times when they are evaluated.

Expanded outputs

Allow expanded outputs of List type.

..(map write [1 2 3])

Nested let for functions