Steak 1.0

A programming language which provides generalized algebraic data types, pattern matching and lazy evaluation based on C++17.

Installation

As a domain specific language powered by C++ macros

Just copy include/runtime.h, include/steak.h, include/ret_type_impl.h into your project and #include "steak.h". Be sure your C++ compiler support C++17 standard.

As a programming language powered by a compiler with C++17 backend.
1. install haskell-stack
2. clone this repository
3. run stack install
You can try it with docker, see the Dockerfile in this repo.

Steak Language Documentation

Steak programming language inherits C++17 completely except that match and dataclass are keywords.

The extension names of Steak are .stk.cpp,.stk.hpp or .stk.h. The compiler will compile source files to c++17 code.

Usage

steak file: compile the source file and print the object code to stdout
steak dirctory: search the directory recursively and compile all *.stk.cpp,*.stk.h,*.stk.hpp to *.cpp,*.h,*.hpp
steak --version: version and license
steak --help: help

Language Specification

dataclass is for defining generalized algebraic data types. Usage: [] means optional

[template<...>] dataclass adt
{
    return_type constructor1(...);
    return_type constructor2(...);
    ...   
};

match is for pattern matching. It's similar to switch expression. Usage:

match(var)
{
    case Cons1(...):
        ...
    case Cons2(...):
        ...
    default:
        ...
}

Examples are available at examples/

Warnings

Remember that compiler won't deal with macros. As a result, don't use macros in dataclass or match expressions.
In the case Cons(...) expression, only literals and identifiers are allowed, operators and function call are not allowed.For example,Just(x) and Just(1) are valid, while Just(x.c) or Just(1+3) are invalid. Constructor with no paramenter also need to be followed by (), for example, case Nothing().
If you know the implementations of the library and the compiler, you will understand all the strange things.

C++ DSL Documentation

generalized algebraic data types

Generalized algebraic data types can be defined via C++ macros.

Let's take
```
data List a = Cons a (List a) deriving Show
```
as an example:
```
RegCons(Nil) RegCons(Cons)
Data(Va,List,RealType(Nil),RealType(Cons,a,List<a>))
    Cons0(Va,Nil,List<a>)
    Cons2(Va,Cons,a,List<a>,List<a>)
DerivingShow(Va,List<a>)
```
Another example :
```
data Peano = Z | S Peano deriving Show
```
```
RegCons(Z) RegCons(S)
Data(V,Peano,RealType(Z),RealType(S,Peano))
    Cons0(V,Z,Peano)
    Cons1(V,S,Peano,Peano)
DerivingShow(V,Peano)
```
- At first, you should register the constructors' name using RegCons.
- macro Data is for defining the data structure in C++, and macro RealType is for inferencing the actual type of case classes.
- Va is short for template<typname a>, while V means Nothing. If you want to use 2 type variables,you can use Vab.
- Cons[d] can be used to define constructors,d is the number of parameters. Cons2(Va,Cons,a,List<a>,List<a>) means Cons::a->List a->List a
- DerivingShow is not necessary.

pattern matching

int maybe_sum(steak::lazy_type_t<List<Maybe<int>>> l)
{
    int x=0,y=0;
    while(1)
    {
        With(l)
            Case(Cons,UnZip(Just,y),l)
                x+=y;
            Case(Nil)
                break;  /* break while(1) */
            Case(Cons,UnZip(Nothing),l)
                ;            
        EndWith()
    }
    return x;
}

With(x) starts a pattern matching for x and x must be lazy_type_t<adt> or adt
Case(constructor name,parameters...) is for matching, {} and break is not necessary. You can also use Unzip for nested pattern matching.

lazy evaluation
- lazy_type_t is a template class to seal data types in C++. Constructor functions with the actual name returns a adt value, while functions followed by _ returns a lazy_type_t<adt> value. For example, Cons is a strict constructor and Cons_ is a lazy constructor. warning: If the constructor takes more than 5 parameters, the parameters must be all instant values or all lazy_type_t s.
- Apply[d] are macros for calling function and putting off evaluation. Similarly, they only receieve all instant values or all lazy_type_t s as parameters.
currying functions
- use std::bind to construct paritial applied functions.

Note

The compiler and the library works well with GCC 7.2.0

Feel free to contact me if you want to know more about Steak.

overlogged/steak