Programming Languages

1102 readers

6 users here now

Hello!

This is the current Lemmy equivalent of https://www.reddit.com/r/ProgrammingLanguages/.

The content and rules are the same here as they are over there. Taken directly from the /r/ProgrammingLanguages overview:

This community is dedicated to the theory, design and implementation of programming languages.

Be nice to each other. Flame wars and rants are not welcomed. Please also put some effort into your post.

This isn't the right place to ask questions such as "What language should I use for X", "what language should I learn", and "what's your favorite language". Such questions should be posted in /c/learn_programming or /c/programming.

This is the right place for posts like the following:

"Check out this new language I've been working on!"
"Here's a blog post on how I implemented static type checking into this compiler"
"I want to write a compiler, where do I start?"
"How does the Java compiler work? How does it handle forward declarations/imports/targeting multiple platforms/?"
"How should I test my compiler? How are other compilers and interpreters like gcc, Java, and python tested?"
"What are the pros/cons of ?"
"Compare and contrast vs. "
"Confused about the semantics of this language"
"Proceedings from PLDI / OOPSLA / ICFP / "

See /r/ProgrammingLanguages for specific examples

Related online communities

founded 1 year ago

MODERATORS

armchair_progamer

term-lisp: very simple lisp dialect based on pattern matching and term rewriting (github.com)

submitted 3 months ago by armchair_progamer to c/programming_languages

0 comments fedilink hide all child comments

[term-lisp] does not support variables, and its functions are rules that describe how to replace a given term with another one.

For example, consider how the booleans are defined:
(true = Bool True)
(false = Bool False)
This means "when you see the term "true", replace it with the term "Bool True"

...

term-lisp supports first-class pattern matching. This means that you can have functions that return patterns.

For example, consider how the if expression is defined:
(if (:literal true) a b = a)
(if (:literal false) a b = b)
Here the terms true and false are automatically expanded, so the expressions above are a shorthand for:
(if (:literal (Bool True)) a b = a)
(if (:literal (Bool False)) a b = b)

...

To prevent unwanted execution, expressions in term-lisp are evaluated lazily i.e. only when they are needed.

...

What happens if we construct an expression that looks like function application, but the function being applied is not defined? In most languages, this would result in error, but in term-lisp we will create a new datatype/constructor, e.g. the expression Pair foo bar would evaluate to... Pair foo bar i.e. we will save a new object of type Pair, containing the values of foo and bar.

no comments (yet)

sorted by: hot top controversial new old

there doesn't seem to be anything here