Statically Typed Programming Language Puns

https://github.com/05st/capri

The compiler targets C and is written in Haskell.

Is there a language that fills these requirements? Something in between Elixir/Clojure and Haskell. I want the power of static typing plus the flexibility of not striving for pure functions at all costs.

I see that Java has a Class class which cuddly-studiates all code in Java. What is the distinction between Class, and the public keyword that identifies Class as the "first" type?

Hi! I tried to start machine learning (with tensorflow and scikit) but the dynamic nature of Python exhausts me. I'm looking for a statically typed tech stack for ml (language + framework), without the python/c++ double layer. What's your advice? Thanks a lot

Hi programmers!

I have started to work on this for about 2 days now and so far, I see many potentials about this design choice.

This is a virtual machine I'm creating for my programming language foxo (functional, statically typed) and I was trying to come up with an idea. Then suddenly something like this popped up in my head: why not use bytes and pointers only?

And so, this is the result after 2 days: https://www.gitlab.com/flurach/celer

During the last three month I implemented a validating Oberon to LuaJIT compiler and an IDE with integrated source level debugger.

Here are two screenshots: http://software.rochus-keller.info/screenshot_oberon_system_in_debugger.png and http://software.rochus-keller.info/screenshot_oberon_ide_0.5.1.png. You can download a complete Windows binary from here:http://software.rochus-keller.info/OberonIDE_win32.zip.

As you might know from my previous posts (see e.g. https://www.reddit.com/r/lua/comments/dgu2qq/compiling_other_languages_to_luajit_implementing/) I'm interested in re-using LuaJIT as a runtime environment for strictly/statically typed languages (and later as a HDL simulation engine). Oberon (see https://en.wikipedia.org/wiki/Oberon_(programming_language)) has proved to be very suitable as a proof-of-concept because it is not a complex language but still powerful enough to demonstrate the feasibility. The full Oberon-07 language is implemented as defined in https://people.inf.ethz.ch/wirth/Oberon/Oberon07.Report.pdf (but no SYSTEM module).

The IDE and compiler are implemented in C++ using Qt. Compilers and tools for other languages will follow.

See https://github.com/rochus-keller/Oberon, https://github.com/rochus-keller/LjTools and https://github.com/rochus-keller/OberonSystem for more information.

Do you program in statically typed languages with Vim? If so, how long have you programmed in that language? What do you do? I'm curious because I only ever program JS, Ruby, Python, Bash with it.

The links:

Rae ”Compiler” at Github

OpenGL cube in Rae

Hello World.

Lately I’ve been prototyping a native statically typed toy programming language which I’m calling Rae (just a hobby, won’t be big and professional like Rust).

Here’s some of the features:

• optionals, no semicolons, single source files, short words instead of sigils
• compiles to almost readable C++11
• the compiler will break on about any code you throw at it, and it is written in the most horrible style, as it was just intented to be a temporary proof of concept. :)
• influenced by C++, D, Python, Nim, Swift, Rust and Jai

The defining feature of Rae is that each variable has a ”kind”, which can be one of:

• val : for value. Value types are usually the default, so you can leave it out.
• ref : for reference. Refs own their memory. Reference types are the default for function parameters.
• opt : for optional. Opts own their memory.
• link : for link. A sort of pointer in two directions. Links don't own their memory. They can point to vals, refs or opts.
• ptr : a pointer type for interfacing with C/C++.

So a function that doesn’t do anything reasonable might look a bit like this:

func (int named_return) someFunc (ref SomeClass something, int param2)
{
    val OtherClass other
    int res = other.callAFunc(param2)
    return something.whatsThat(res)
}

Missing features:

• Inheritance, multiple inheritance, interfaces
• Multiple return values
• Make the compiler more robust, and well, rewrite it :)
• Built in types don't handle kind correctly
• Strings are practically not handled at all in many cases

Feedback on the syntax and semantics will be appreciated. Although I’m not very serious about pushing this thing any further :). I still might, as it is so fun to code with this language, in my opinion.

I get the impression the dynamic typing of Python is one of the biggest speed bottlenecks. I also like the idea of static typing just because it forces you to think more about what you are writing and what each step is doing.

Is there some language that feels like Python in every other way, but is statically typed?