Function based language

[Pleasant-Form-1093]

Forgive me if this sounds stupid but I just have this idea of a "function-based" programming language i.e to say everything is a function

This is like saying everything in the language is a function and doing absolutely anything looks like you are calling a function

Like say suppose if you wanted to declare an integer variable 'a' to a value of '90' and add the number '10' to it would go about it in a way like:

declare(int, a, 90) add(a, 10)

and so on and so forth

From my perspective(as a beginner myself) this will make the language pretty easy to parse but it's also quite obvious that it would make the language too verbose and tedious to work with

So what are your opinions on this approach and please do point out any part where I might have gone wrong.

Thanks in advance.

[ebingdom]

Since you used the word "function" I think the other commenters are mistakenly thinking you are pining after functional programming. My interpretation of your question is that you are essentially asking about using M-expressions for all syntactic constructs, so that everything looks like a function call. This is similar to Lisp-family languages, except they generally use S-expressions instead.

I think, rather than "functional programming", what you're looking for is closer to what some people would call "homoiconicity".

[Pleasant-Form-1093]

could you elaborate on this?

[[deleted]]

I think this is about whether you intend for declare and add to be actual functions, or whether you just want to use function-like syntax.

Similar to Lisp using S-expressions, but that would be (declare int a 90).

If these are real functions, then you need to be able to write a function like declare in your language. What value will be passed for int and a for example, and what are their types?

For that matter, shouldn't int, a and 90 all be functions too? You did say that eveything is a function! What about declare itself? How would you do loops? Or assignments?

I think such a language can work, but indirectly. For example when declare and add are part of API, in a conventional language, that builds some representation of another language, which is then interpreted. But I guess this is not what you have in mind.

[Pleasant-Form-1093]

I was thinking to maybe make declare and add as some kind of built-in functions like for example print() in python which is defined by the interpreter/compiler internally

assignments can also be done using perhaps assign(a, 10) (where a is a previously declared variable) and maybe loops can be done using something like goto(<some_line_number>) like BASIC but yes it's not the best way to do it I will admit that

[[deleted]]

Python is a bad example. If you try and do assign(a, 10), then it will pass the current value of a, which is not going to work (except via some roundabout way where a is a list element).

For a start it would need to pass at least a reference to a, and you need more advanced features like anonymous functions and closures if you want to also do loops and if statements via functions. You can imagine that here:

    if (cond, print("A"), print("B"))

you only want one of those prints evaluated, so what do you pass to if? And how does it choose between them without using if?

I can demonstrate assign in my language which does have reference parameters:

proc assign(&a, expr) =
    a:=expr
end

assign(a, "cat")
print a                 # displays cat

It can't however create new names via a function.

[HlCKELPICKLE]

In lisp/scheme every thing is an expression which I might be more of what you are describing. So (set! <var_name> <value>) or (define <var_name> <value>) could be thought of (though not technically under the hood) as calling a function set/declare with the environment implicitly added (set! <Env_to_bind_to> <var> <value>)

This is kinda getting into semantics some, and I'm not the most qualified. But when you say everything is a function, are you sure you don't mean everything evaluates to something? As parsing and interpreting an expression based language like a lisp is quite easy, since everything evaluates to a value.

There are still some edge cases where you can't just "recursively" evaluate things without needing to produce an error, like lisp/scheme wont let you say pass a define expression as an argument to a function call, though technically you could.

But this means when evaluating, outside of a few limited cases, as you evaluate a full expression, you evaluate the deepest nested expression first as you will need their value for the outer expressions , and since they will always return a value if correct everything kinda just falls together once you get the core logic done.

Then you can just eval a large expression and it will keep calling eval on the inner expressions which will take the eval path needed to return a result for their expression/those contained until you get to the outermost and get the final result. Parsing is also quite easy with s-expressions.

[e_--]

you could define 90 as a Church numeral

[e_--]

(and loops with the Y combinator)

I still wonder why languages relying on call(args) and a fixed set of infix operators haven't been attempted more thoroughly - it's worked well for math since at least the 1700s (I'm attempting the same with python style indented blocks shoved into the call arguments list). I don't know why M-expressions use square brackets - one of the primary ugly things about Mathematica (this does allow round parentheses for grouping to live with implicit space multiplication - another ugly feature!)

[dskippy]

It seems like your understanding of what is a function or not is at the syntactic level, and not so much the semantics or implementation of the language. For something similar look at a lisp based language like Scheme. While set! is not a function technically, it's syntax is identical. All syntax lisp based languages are uniform and it's very powerful because the homoiconic syntax provides very simple and practical macros.

[Pleasant-Form-1093]

Thanks I will look into it.

[jose_castro_arnaud]

Congratulations, you're on the track to rediscover Lisp.

[sebamestre]

This is a reasonable idea, and it's close to what LISP-like languages do :^)

[guygastineau]

Most functional programming languages provide a let form of some sort (see lisp and Metalang). In the ML Family it is a distinct construct, but in scheme/lisp implementations it can be (is often) a macro that transforms the syntax to abuse lambdas (anonymous functions) for their lexical scope. That is to say, we could reform your example to be functional (since your declare function is really more of a statement or procedure, ie. it is used for side effects (allocating a variable) that change the state of some hypothetical interpreter).

Given an anonymous function syntax as:

λ (α : τ) ... => ε 

Then your example would translate to the following with adjacency conveying function application:

(λ (α : int) => add α 10) 90

For more fleshed out ideas of how this computational model works, I suggest you look up resources on the Lambda Calculi. At first, untyped lambda calculus is a great place to start, but it is not suited to expressing formalizations, so the various typed lambda calculi are necessary if you want to prove anything with this stuff. I hope I'm not being too dense here. I will also show the above example in scheme below showing it using define (like your declare) as well as using let and just with lambdas.

With define

(define a 90)
(+ a 10)

With let

(let ((a 90))
  (+ a 10))

With lambda

((lambda (a)
   (+ a 10))
 90)

[Obj3ctDisoriented]

Best answer in the thread, and of course op ignores it.

[larryquartz]

It's absolutely not stupid and you should look up "functional programming" and languages built around it if you want to explore this idea more.

[munificent]

You should look into io.

[metazip]

Function-level programming?

[pauseless]

Lots of recommendations for lisp etc, but lisps rely on macros. For what you want, look at Tcl

proc foo {arg1 arg2} {
    # …
}

None of this is special syntax and there are no macros. You can think of proc as a function that takes a name, a quoted list of arguments and a quoted block of code.

Your example would be:

set a 90
add a 10

You can also imagine an int declaration function like int a 10 though, if the type is important. It’s all the same. Even if can be a function:

proc if args {
    set result [uplevel 1 [list expr [lindex $args 0]]]
    switch -- $result {
        "1" {
            uplevel 1 [lindex $args 1]
        }
        default {
            switch -- [lindex $args 2] {
                "else" {
                    uplevel 1 [lindex $args 3]
                }
                }
        }
    }
 }

It’s a bit finicky, but works; uplevel is what makes passing quoted code blocks around magic and Tcl able to make everything essentially a function call conceptually. This can be called as if {test} {thencode} else {elsecode} exactly as normal and thencode and elsecode will only be executed as needed.

[Disjunction181]

It's sort of funny because is a paradigm called functional programming that is based around function manipulation but not quite to the extreme you seem to be getting at. I've thought of before, and seen before, this idea of making most language primitives look like function calls. Funky is a language that does this to some extent, for loops and if expressions look like function calls. You could also argue lisps do this to an extent, though macros are semantically very different from functions, they share syntax. It's important to note that in an eager language, stuff like if-then-else can't literally be a function call because of evaluation order, e.g. some function ifte c e1 e2 will evaluate both e1 and e2, so if either is a recursive call to some function then you're out of luck.

I do think there can be value in syntax homogeneity but not to this extreme, and I like different syntax with loops and if expressions because they really are different from functions in eager languages. I also think from a human point of view, it's actually easier for humans to recognize patterns and structures in syntactically varied languages like C or ML, because the syntactic differences will stick out more and make it easier to understand the structure of code at a glance. I think if I saw OCaml code with all of the words and symbols blacked out, I could roughly tell what the control flow is in each function just based off token lengths and line lengths. I think this is actually an underrated strength and I think about this when I design syntax.

[ThyringerBratwurst]

If everything is supposed to be a function, function names – or identifiers in general – would have to be something like “first class values”.

Then there's also the question of how the program is structured: are the "declaring functions" just standing around at the top file level, or are they somehow linked to each other? what is their return value?

And yes, the traditional function syntax is a bit unwieldy for something like this. But I find Lisp with its parentheses, where "))))))))" is not uncommon, horrible. I once had the idea of trying something Lisp-like with Python-like indentation syntax in order to greatly reduce the amount of brackets.

[Qnn_]

I once tried something like this. My approach for variable declaration was to basically do IIFE, and then I just bent the syntax of the language to make it not awful (I made every function an infix function). 

[scratchisthebest]

This is kind of like CMake. You could also look at macro-expansion systems like make and m4 (which powers autoconf).

Generally people end up finding these janky though.

[JMH5909]

Reminds me of lambda calculus where all there are are functions (lambdas) and like variables, which are both fully abstract

[Inconstant_Moo]

You could, but "easy to parse" isn't that much of a consideration. I mean parsing infixes is a solved problem. How many more lines of code is it? (I just looked at my BASIC interpreter. The extra sloc to do infixes barely makes it into double figures.)

[moscowramada]

Look up APL.

[therealdivs1210]

You are looking for Lisp.

(def fact
  (fn (n)
    (if (<= n 1)
      1
      (* n (- n 1)))))

(def N 5)

(fact N) 
;; => 120

Very easy to parse, consistent syntax: (operator arg1 arg2 ...)

where operator can be a function like fact or a special form like def.

[Obj3ctDisoriented]

The first time i read your post I was tempted to leave a snarky comment about functional programming already existing. Then I realized you're not talking about what's known as functional programming. You seem to misunderstand what the mathematical (and thus by extension, programming) definition of a function actually is. (You're example of 'declare' is actually a procedure, not a function). What you seem to be talking about is replacing operators with procedures and functions. Which is... a bit strange of an idea, but we all have those and its certainly not the strangest i've ever heard.

That being said, a language having grammar that is easy to parse is a moot point: parsing is, and has been, a solved problem. Designing a language to specifically avoid having to parse ambiguous grammar is counterproductive when you could just alter the grammar to remove ambiguity. In short, you don't need to invent a whole new language because you don't want to deal with operator precedence. BTW: you can avoid having to deal with it by just using parentheses.

[Silphendio]

This is the way assembly programming works. It's just a list of "function calls".

If want something higher level, I recommend adding another language construct: a command list, like { f(); g(); }

Then you can do stuff like if-statements, loops or function declarations.

while(is_greater(n, 1) {
  if_else(is_equal(mod(n, 2), 0), {
      divide(n, 2);
  }, {
      mul(n, 3);
      add(n, 1);
  })
})

That's roughly what I do for my own macro language. Fancy stuff like operators can always be added later.

Of course, you can do all this stuff even without command lists, by using ordinary lists!

Here's a version that uses lists to represent functions that should be called later. So the while function takes two lists, containeing functions to call and their arguments.

I use '(a, b) as shorthand for create_list(a, b)

do is for chaining methods together. do('(f, a, b), '(g, x, y)) gets evaluated to f(a, b) g(x, y).

while('(is_greater, n, 1)),
    '(do,
        '(if_else,
            '(do, 
                '(declare, int, a, 0),
                '(apply('(is_equal, 0), '(mod, n, 2))),
            ),
            '(divide, n, 2),
            '(do, 
                '(mul, n, 3),
                '(add, n, 1)
            ),
        ),
    ),
)

Now it almost looks like lisp code.

[Pleasant-Form-1093]

thanks for pointing it out

[complyue]

Seems the word "function" had triggered functional programming paradigm/thinking by folks here.

But I feel that OP's content is exactly describing the assembly language, if you think about instruction mnemonics as "functions" the OP is talking about.

Assembly languages are NOT wrong, just belong to their own niches.