t3_1ggnlkb

Toffee is an object-oriented class-based programming language that I made for macOS (no Windows support). Read the documentation first. Use it at txnyurl.com/toffee-sdk at the end of that (replace the lowercase X with a lowercase I).

Here is a Hello World program in it:

    public class HelloWorld {
      print("Hello, World!");
    }

<div class="md">Toffee is an object-oriented class-based programming language that I made for macOS (no Windows support). Read the documentation first. Use it at txnyurl.com/toffee-sdk at the end of that (replace the lowercase X with a lowercase I).

Here is a Hello World program in it:

<pre><code>public class HelloWorld {
 print(&quot;Hello, World!&quot;);
}
</code></pre>
</div>

Toffee

t3_1gexohh

The QED programming language: innovative web app development (and also trying to solve "the GUI problem")

t3_1gc7qa5

Trygve: a DCI-centric language

t3_1g1kxsg

The Safe-C Programming Language

t3_1fple3x

Cello: C alternative library to bring higher level programming

t3_1foh9jq

Hey everyone! I’m working on a [Dataflow programming language](https://github.com/nevalang/neva), and I need some advice on structuring the standard library, particularly for conversions between different data types.

The key data types in my language are **lists**, **dictionaries**, and **streams**. The go-to way to work with any iterable data, like applying map, filter, reduce, is through **streams**. So, when you have a list or dictionary, the first thing you usually do is convert it into a stream to iterate over it.

This means I need to support conversions like:

- **list → stream**
- **stream → list**
- **dict → stream**
- **stream → dict**

My question is: **How should I structure and name these conversion functions in the standard library?**

Context:

- The language uses Go-like package structures and imports
- Components (you can think of them like classes) are the only way to type-cast
- Component instance by default has same name as component but lowerCase

Given this, here are options that I see

## Everything under `streams` package

```
streams.FromList
streams.ToList
streams.FromDict
streams.ToDict
```

You woild have to import `streams` package a lot, also instances of these components would have names `fromList`, `toList`, `fromDict` and `toDict` by default which might be not the most obvious naming (what do we get from list? what do we cast to list?).

## Split between `streams`, `lists` and `dicts` packages

```
lists.FromStream
dicts.FromStream
streams.FromList
streams.FromDict
```

Or

```
lists.ToStream
dicts.ToStream
streams.ToList
streams.ToDict
```

We have the same problems that we have to import some packages (now we need to import more packages) and that instances would have not most obvious naming like `fromStream`, `fromList`, `fromDict`, `toStream`, `ToList` and `toDict`. Also it's not clear first or second variant must be chosen and why.

## Keep everything under `builtin`

Just like in Go I have `builtin` package with entities available without imports. It's possible to keep everything there:

```
ListToStream
StreamToList
DictToStream
StreamToDict
```

You don't have to import anything, also naming is obvious. Only downside I can see is that it makes builtin namespace bigger. Also, even though instance names would be clear, they are also longer: `listToStream`, `streamToList`, `dictToStream`, `streamToDict`.

Also `To` could be replaced with `2`:

```
List2Stream
Stream2List
Dict2Stream
Stream2Dict
```

---

I’m leaning toward making things as clean and user-friendly as possible. What do you think? What have you seen work well in other languages with similar needs? Thanks for your input!


<div class="md">Hey everyone! I’m working on a <a href="https://github.com/nevalang/neva">Dataflow programming language</a>, and I need some advice on structuring the standard library, particularly for conversions between different data types.

The key data types in my language are lists, dictionaries, and streams. The go-to way to work with any iterable data, like applying map, filter, reduce, is through streams. So, when you have a list or dictionary, the first thing you usually do is convert it into a stream to iterate over it.

This means I need to support conversions like:

<ul>
<li>list → stream</li>
<li>stream → list</li>
<li>dict → stream</li>
<li>stream → dict</li>
</ul>

My question is: How should I structure and name these conversion functions in the standard library?

Context:

<ul>
<li>The language uses Go-like package structures and imports</li>
<li>Components (you can think of them like classes) are the only way to type-cast</li>
<li>Component instance by default has same name as component but lowerCase</li>
</ul>

Given this, here are options that I see

<h2>Everything under <code>streams</code> package</h2>

<code>
streams.FromList
streams.ToList
streams.FromDict
streams.ToDict
</code>

You woild have to import <code>streams</code> package a lot, also instances of these components would have names <code>fromList</code>, <code>toList</code>, <code>fromDict</code> and <code>toDict</code> by default which might be not the most obvious naming (what do we get from list? what do we cast to list?).

<h2>Split between <code>streams</code>, <code>lists</code> and <code>dicts</code> packages</h2>

<code>
lists.FromStream
dicts.FromStream
streams.FromList
streams.FromDict
</code>

Or

<code>
lists.ToStream
dicts.ToStream
streams.ToList
streams.ToDict
</code>

We have the same problems that we have to import some packages (now we need to import more packages) and that instances would have not most obvious naming like <code>fromStream</code>, <code>fromList</code>, <code>fromDict</code>, <code>toStream</code>, <code>ToList</code> and <code>toDict</code>. Also it&#39;s not clear first or second variant must be chosen and why.

<h2>Keep everything under <code>builtin</code></h2>

Just like in Go I have <code>builtin</code> package with entities available without imports. It&#39;s possible to keep everything there:

<code>
ListToStream
StreamToList
DictToStream
StreamToDict
</code>

You don&#39;t have to import anything, also naming is obvious. Only downside I can see is that it makes builtin namespace bigger. Also, even though instance names would be clear, they are also longer: <code>listToStream</code>, <code>streamToList</code>, <code>dictToStream</code>, <code>streamToDict</code>.

Also <code>To</code> could be replaced with <code>2</code>:

<code>
List2Stream
Stream2List
Dict2Stream
Stream2Dict
</code>

<hr/>

I’m leaning toward making things as clean and user-friendly as possible. What do you think? What have you seen work well in other languages with similar needs? Thanks for your input!
</div>

[Question] How should I structure my standard library for data type conversions in a Dataflow language?

t3_1fohadl

t3_1fo2wzr

"Hy (or "Hylang" for long) is a multi-paradigm general-purpose programming language in the Lisp family. It's implemented as a kind of alternative syntax for Python."

t3_1fhgfez

The Sage Programming Language🌱

t3_1fh6ma2

"Tal is the programming language for the Uxn virtual machine."

t3_1fh65v8

"The Factor programming language is a concatenative, stack-based programming language with high-level features"

Koka: A Functional Language with Effect Types and Handlers

Curry: A Truly Integrated Functional Logic Programming Language

EYG: A functional language that can run anywhere 

Fennel: a LUA-compatible language, with a LISP-based syntax

8th: a commercial FORTH-derivative with tooling for database and document use

MoonBit: a new language intended to produce WASM output

Bashf-ck: Write any bash with only the punctuation characters

"Vala is an object-oriented programming language with a self-hosting compiler that generates C code and uses the GObject system."

 Callisto Programming Language: compiled, low-level, concatenative language inspired by Forth

Coconut Programming Language: variant of Python that adds features for functional programming

Hello guys! It's been a while since I last updated the MiniLang programming language. The language aims to be powerful, yet concise, simple and minimal. Check it out if you find this interesting.

Additions:

\* Structures

\* Function overloading

\* Uniform function call syntax (UFCS)

\* C-based compiler backend (by default)

\* Some builtins

Link: \[https://github.com/NICUP14/MiniLang\](https://github.com/NICUP14/MiniLang)

# Mini Lang

A type-safe C successor that compiles directly to c.

# Features

\* Minimal

\* Compiled

\* Strongly typed

\* Function overloading

\* Hygienic macro system

\* C function interoperability

\* Uniform function call syntax (UFCS)

Minimal - As close as possible to actual assembly code while maintaining as many high-level features as possible.

<div class="md">Hello guys! It&#39;s been a while since I last updated the MiniLang programming language. The language aims to be powerful, yet concise, simple and minimal. Check it out if you find this interesting.

Additions:

* Structures

* Function overloading

* Uniform function call syntax (UFCS)

* C-based compiler backend (by default)

* Some builtins

Link: [<a href="https://github.com/NICUP14/MiniLang%5C%5D(https://github.com/NICUP14/MiniLang)">https://github.com/NICUP14/MiniLang\](https://github.com/NICUP14/MiniLang)</a>

<h1>Mini Lang</h1>

A type-safe C successor that compiles directly to c.

<h1>Features</h1>

* Minimal

* Compiled

* Strongly typed

* Function overloading

* Hygienic macro system

* C function interoperability

* Uniform function call syntax (UFCS)

Minimal - As close as possible to actual assembly code while maintaining as many high-level features as possible.
</div>

MiniLang

"QB64 is a modern extended BASIC programming language that retains QBasic/QuickBASIC 4.5 compatibility and compiles native binaries for Windows, Linux, and macOS."

C3: A C-like language that builds on the syntax and semantics of the C language

GETlang: "A query language for the web"

"Horse64 is a high-level language that combines readability, clean dynamic typing, and readiness for large projects. A more grounded rethinking of Python."

Mint 🌿 The programming language for writing single page applications (SPA)

Bend: "A massively parallel, high-level programming language"

📜 "Scroll is a language for scientists of all ages"

Cangjie: A new programming language to be soon introduced by Huawei

"Minispec is a simple but full-featured Hardware Description Language (HDL)"

There are roughly [7000 spoken languages](http://en.wikipedia.org/wiki/Language#Linguistic_diversity): there might be more for programming. You may have heard of BASIC, C#, or Java: but what about Dylan, Brainfuck, or Zimbu? Some languages exist to serve a purpose; some as experiments; some to reinvent the wheel.

* [Wikipedia category listing of programming languages](http://en.wikipedia.org/wiki/Category:Programming_languages)
* [List of esoteric programming languages](http://esolangs.org/wiki/Language_list)
* /r/ProgrammingLanguages : subreddit that discusses language design.
* /r/fork : subreddit that catalogs [software forking](http://en.wikipedia.org/wiki/Fork_%28software_development%29)


**Basic Rules**

* Keep it programming-focused. No random off-topic discussion, politics, porn, etc.
* Ideally, here we want to catalog & discuss languages that don't typically end up on resumes or /r/programming.
* If you have your own programming language, and want to plug its site, subreddit, etc; that's fine here. Just don't overdo it. ;)

<div class="md">There are roughly <a href="http://en.wikipedia.org/wiki/Language#Linguistic_diversity">7000 spoken languages</a>: there might be more for programming. You may have heard of BASIC, C#, or Java: but what about Dylan, Brainfuck, or Zimbu? Some languages exist to serve a purpose; some as experiments; some to reinvent the wheel.

<ul>
<li><a href="http://en.wikipedia.org/wiki/Category:Programming_languages">Wikipedia category listing of programming languages</a></li>
<li><a href="http://esolangs.org/wiki/Language_list">List of esoteric programming languages</a></li>
<li><a href="/r/ProgrammingLanguages">/r/ProgrammingLanguages</a> : subreddit that discusses language design.</li>
<li><a href="/r/fork">/r/fork</a> : subreddit that catalogs <a href="http://en.wikipedia.org/wiki/Fork_%28software_development%29">software forking</a></li>
</ul>

Basic Rules

<ul>
<li>Keep it programming-focused. No random off-topic discussion, politics, porn, etc.</li>
<li>Ideally, here we want to catalog &amp; discuss languages that don&#39;t typically end up on resumes or <a href="/r/programming">/r/programming</a>.</li>
<li>If you have your own programming language, and want to plug its site, subreddit, etc; that&#39;s fine here. Just don&#39;t overdo it. ;)</li>
</ul>
</div>

<div class="md">There are roughly 7000 spoken languages: there might even be more for programming. You may have heard of BASIC, C#, or Java: but what about Dylan, Brainfuck, or Zimbu? Some languages exist to serve a purpose; some as experiments; some to reinvent the wheel.
</div>

Alternative programming languages

1,328 Subscribers

Toffee

[Question] How should I structure my standard library for data type conversions in a Dataflow language?

MiniLang

Mini Lang

Features