Bento Box Lang

LISP macros
Standard imperative syntax
Extensive math library
Complex and Rational numbers
native machine types for math
As fast as C
GPU and Distributed computing capability
LLVM based
Calling C functions directly
Multiple dispatch
Unicode UTF-8
Type-bound operators
types are runtime objects
Runtime type inference
Open Source
Lightweight Green threads/coroutines
GC is incremental with no pauses
Shell capabilities and REPL
Multidimensional arrays
True module system and textual #inclusion
Reflection and access to intermediate bytecode
Can be embedded inside C code with a single header

types are runtime objects

Stopped reading right there. To the trash-can.

>>2
Type system:dynamic, nominative and parametric.
Runtime types allow dynamic flexibility with static type speed via type inference.
You can use primitive types and parametric types too.
hierarchical relationships between types are explicitly declared,
concrete types may not subtype each other: all concrete types are final and may only have abstract types as their supertypes.
all values are true objects having a type that belongs to a single, fully connected type graph, all nodes of which are equally first-class as types.
Both abstract and concrete types can be parameterized by other types.Only values, not variables, have types — variables are simply names bound to values.

>>3

Runtime types allow dynamic flexibility with static type speed

If types are runtime objects, they inevitably create overhead, so I doubt you have "static type speed".

>>4

native machine types for math

>>4

native machine types for math

>>5
I wasn't talking about math, I was talking about values. Runtime types always cause overhead.

>>7
You can always add annotations or conversion to runtime types making them concrete and produce abstract types from the concrete.

>>8
How will that remove the overhead of runtime type reification?

Besides, I can't even Google your language, is it real?

>>9
It was a joke on "the perfect bento Box"
The name is Julia language. Its a buggy mess atm but extremely powerful.

Also, the entire thread
http://bbs.progrider.org/prog/read/1422195866

>>9
Haskell-faggu doesn't know the bento box.

ハハハッです

>>10
I've never even heard of Bento boxes.

>>12
I'm not a "faggu", faggot.

>>13
https://encyclopediadramatica.se/Copypasta/Archive_1#Bento_Box

>>15
So it's weeaboo for "lunchbox". Fun.

OP is so retarded.

>>14 (faggu)
Yes, you are.

>>17
Fuck you and your puta madre, cabron.

>>16
The OP title refers to >>11 thread which is a snowclone of 10-year old copypasta in >>15 which is based on Japanese tradition on creating beautiful bento boxes.
Bento arrangement can be a form of art, it can depict anime characters, animals or other motifs with food and bento box itself can be handcrafted or designed with specific look or theme.

I like lumberjack bento.

Julia language needs a kawaii mascot(it can be pinku). Something cute and math-related, symbolizing its number crunching power and lisp-like flexibility.

C H E C K ' E M C U N T Z

>>22
Don't call me a cuntz, nigger.

I need a bento box for my burgers.
One kotoba for the burger(s), one kotoba for the fries.
Should be approximately small pizza box sized but taller

GC

dropped

>>25
Dumb motherfucker.

>>25
u mena finalized

Julia macros seem nice, but not something i'd abandon C for.
C macros answer 90% of use cases and the rest can be implemented as functions. After all macros are just a crutch for generating real code, and the latter can be always written by hand.
Same with operator overloading, which can be abstracted as single macro e.g. add(x,y) without making the expression cryptic(operators depending on types are nice to write, bad to read as they hide complexity/cost). So Julia has 0 "killer features" for me.
I wish people improved C preprocessor instead(by adding something like #macro/#endmacro with Julia macros to C standard) of writing next "hip language of the future that will supplant everything". At the least it would make writing next "hip language of the future" more productive as they all are C/C++ inside.

>>28
This would create a complex interpretation stage.
1.text processing:#define f(x,y)
2.interpretation:#macro , typeinfo& _Generic? builtin functions? basic math?
3.compilation

>>28
This would create a complex interpretation stage.
1.text processing:#define f(x,y)
2.interpretation:#macro , typeinfo& _Generic? builtin functions? basic math?
3.compilation

>>21
Yuki Nagato

>>28
Why not write your own preprocessor that adds #macro? Is it too hard?

>>32
Why not write your own preprocessor that checks dubs is it too hard?

>>33
No, it's just retarded.

>>32
I could spend much time implementing this, but my version of C would be non-standard and unsupported by all other compilers.
As i stated i want the standard modified to allow #macro to execute at compile time and produce code, as in Julia. Its been decades since C preprocessor got any notable improvement.
C isn't going anywhere and improving C preprocessor improves everything thats written in C/C++, languages,OSes, virtual machines and interpreters. Basically, one improvement in C preprocessor is equivalent to improving hundreds of languages and millions of programs. I don't expect anyone to understand it, but "primitive" C preprocessor is essentially the most important language on Earth as the first stage of C/C++ compilation which generates C/C++ code, which drives everything else(virtual machines, OSes, languages,etc). Productivity of programmers is directly proportional to amount of code C preprocessor produces.
LISP macros are a shortcut in lisp to create domain specific code by interpreting the macros as code generating code.
All that needed is to add interpretation of macros as C statements returning strings of code to be inserted into the program.
It doesn't need to be complex:
#macro result(a,b,c) //executed at compile time
char * result_code_string=malloc(1000);
sprintf(result_code_string,"%s%d*%f",a,b+2,c+3.0)
return result_code_string
#endmacro
result("double j=(k())+" , 22 , 2.0 );//macro invoked
double j=(k())+24*5.0;//final macro expansion

Julia dynamic types are not forced.
http://docs.julialang.org/en/latest/manual/types/
Type Declarations

The :: operator can be used to attach type annotations to expressions and variables in programs. There are two primary reasons to do this:

As an assertion to help confirm that your program works the way you expect,
To provide extra type information to the compiler, which can then improve performance in some cases

>>35
Every sane compiler has seperated the preprocessor from the compiler. You could even make it a prepreprocessor, that outputs valid C. You'd have to relax the ambitions of compile-time computation unless you wanted your own lexer though.

>>36

If the type assertion is not true, an exception is thrown

Disgusting.

In other words, in the parlance of type theory, Julia’s type parameters are invariant, rather than being covariant (or even contravariant). This is for practical reasons

Hahaha Julia is shit.

Jewlia

>>37
Sanity is overrated. http://en.wikipedia.org/wiki/The_lexer_hack

Ooooohhh! Guhhaaa... Ooh! Ah! Ah! Ah! AH! AAGGHHH! MOOOOOTHHEEEERR... FUCKKKEERRRRRRRAAAAAGHHHHHH!!!!!

>>42
Don't worry just eat this Sepple and you'll be type-safe.

pinku

>>43
Many Sepples have worms in them.

>>46
Natural Sepples always have worms, its a way of life.
Why would anyone eat GMO Sepples? They cause semicolon cancer and taste like rusted lisping dead dogs.