Funciton
(esolangs • interpreter)
Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and only one datatype (the arbitrary-size integer) and all the useful functions are implemented in terms of this. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.
Example: The Factorial Function
╓───╖
║ ! ║
╙─┬─╜ ┌───╖ ╔═══╗
┌─────┴─────┤ > ╟──╢ 2 ║
│ ╘═╤═╝ ╚═══╝
╔════╗ ┌───╖ │ │
║ −1 ╟──┤ + ╟─┴─┐ │
╚════╝ ╘═╤═╝ │ │
┌─┴─╖ │ ╔═══╗ │
│ ! ║ │ ║ 1 ║ │
╘═╤═╝ │ ╚═╤═╝ │
│ ┌─┴─╖ ┌─┴─╖ │
│ │ ×ばつ ╟──┤ ? ╟──┘
│ ╘═╤═╝ ╘═╤═╝
└─────┘ │
Another example where I actually tried to golf in this language: Render "Digital Clock Style" Numbers Render "Digital Clock Style" Numbers
Funciton
(esolangs • interpreter)
Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and only one datatype (the arbitrary-size integer) and all the useful functions are implemented in terms of this. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.
Example: The Factorial Function
╓───╖
║ ! ║
╙─┬─╜ ┌───╖ ╔═══╗
┌─────┴─────┤ > ╟──╢ 2 ║
│ ╘═╤═╝ ╚═══╝
╔════╗ ┌───╖ │ │
║ −1 ╟──┤ + ╟─┴─┐ │
╚════╝ ╘═╤═╝ │ │
┌─┴─╖ │ ╔═══╗ │
│ ! ║ │ ║ 1 ║ │
╘═╤═╝ │ ╚═╤═╝ │
│ ┌─┴─╖ ┌─┴─╖ │
│ │ ×ばつ ╟──┤ ? ╟──┘
│ ╘═╤═╝ ╘═╤═╝
└─────┘ │
Another example where I actually tried to golf in this language: Render "Digital Clock Style" Numbers
Funciton
(esolangs • interpreter)
Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and only one datatype (the arbitrary-size integer) and all the useful functions are implemented in terms of this. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.
Example: The Factorial Function
╓───╖
║ ! ║
╙─┬─╜ ┌───╖ ╔═══╗
┌─────┴─────┤ > ╟──╢ 2 ║
│ ╘═╤═╝ ╚═══╝
╔════╗ ┌───╖ │ │
║ −1 ╟──┤ + ╟─┴─┐ │
╚════╝ ╘═╤═╝ │ │
┌─┴─╖ │ ╔═══╗ │
│ ! ║ │ ║ 1 ║ │
╘═╤═╝ │ ╚═╤═╝ │
│ ┌─┴─╖ ┌─┴─╖ │
│ │ ×ばつ ╟──┤ ? ╟──┘
│ ╘═╤═╝ ╘═╤═╝
└─────┘ │
Another example where I actually tried to golf in this language: Render "Digital Clock Style" Numbers
Funciton Funciton
(esolangs • interpreter )
Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and only one datatype (the arbitrary-size integer) and all the useful functions are implemented in terms of this. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.
Example: The Factorial Function
╓───╖
║ ! ║
╙─┬─╜ ┌───╖ ╔═══╗
┌─────┴─────┤ > ╟──╢ 2 ║
│ ╘═╤═╝ ╚═══╝
╔════╗ ┌───╖ │ │
║ −1 ╟──┤ + ╟─┴─┐ │
╚════╝ ╘═╤═╝ │ │
┌─┴─╖ │ ╔═══╗ │
│ ! ║ │ ║ 1 ║ │
╘═╤═╝ │ ╚═╤═╝ │
│ ┌─┴─╖ ┌─┴─╖ │
│ │ ×ばつ ╟──┤ ? ╟──┘
│ ╘═╤═╝ ╘═╤═╝
└─────┘ │
Another example where I actually tried to golf in this language: Render "Digital Clock Style" Numbers
Funciton
Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and only one datatype (the arbitrary-size integer) and all the useful functions are implemented in terms of this. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.
Example: The Factorial Function
╓───╖
║ ! ║
╙─┬─╜ ┌───╖ ╔═══╗
┌─────┴─────┤ > ╟──╢ 2 ║
│ ╘═╤═╝ ╚═══╝
╔════╗ ┌───╖ │ │
║ −1 ╟──┤ + ╟─┴─┐ │
╚════╝ ╘═╤═╝ │ │
┌─┴─╖ │ ╔═══╗ │
│ ! ║ │ ║ 1 ║ │
╘═╤═╝ │ ╚═╤═╝ │
│ ┌─┴─╖ ┌─┴─╖ │
│ │ ×ばつ ╟──┤ ? ╟──┘
│ ╘═╤═╝ ╘═╤═╝
└─────┘ │
Another example where I actually tried to golf in this language: Render "Digital Clock Style" Numbers
Funciton
(esolangs • interpreter )
Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and only one datatype (the arbitrary-size integer) and all the useful functions are implemented in terms of this. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.
Example: The Factorial Function
╓───╖
║ ! ║
╙─┬─╜ ┌───╖ ╔═══╗
┌─────┴─────┤ > ╟──╢ 2 ║
│ ╘═╤═╝ ╚═══╝
╔════╗ ┌───╖ │ │
║ −1 ╟──┤ + ╟─┴─┐ │
╚════╝ ╘═╤═╝ │ │
┌─┴─╖ │ ╔═══╗ │
│ ! ║ │ ║ 1 ║ │
╘═╤═╝ │ ╚═╤═╝ │
│ ┌─┴─╖ ┌─┴─╖ │
│ │ ×ばつ ╟──┤ ? ╟──┘
│ ╘═╤═╝ ╘═╤═╝
└─────┘ │
Another example where I actually tried to golf in this language: Render "Digital Clock Style" Numbers
Funciton
Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and only one datatype (the arbitrary-size integer) and all the useful functions are implemented in terms of thesethis. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.
Example: The Factorial Function
╓───╖
║ ! ║
╙─┬─╜ ┌───╖ ╔═══╗
┌─────┴─────┤ > ╟──╢ 2 ║
│ ╘═╤═╝ ╚═══╝
╔════╗ ┌───╖ │ │
║ −1 ╟──┤ + ╟─┴─┐ │
╚════╝ ╘═╤═╝ │ │
┌─┴─╖ │ ╔═══╗ │
│ ! ║ │ ║ 1 ║ │
╘═╤═╝ │ ╚═╤═╝ │
│ ┌─┴─╖ ┌─┴─╖ │
│ │ ×ばつ ╟──┤ ? ╟──┘
│ ╘═╤═╝ ╘═╤═╝
└─────┘ │
Another example where I actually tried to golf in this language: Render "Digital Clock Style" Numbers
Funciton
Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and all the useful functions are implemented in terms of these. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.
Example: The Factorial Function
╓───╖
║ ! ║
╙─┬─╜ ┌───╖ ╔═══╗
┌─────┴─────┤ > ╟──╢ 2 ║
│ ╘═╤═╝ ╚═══╝
╔════╗ ┌───╖ │ │
║ −1 ╟──┤ + ╟─┴─┐ │
╚════╝ ╘═╤═╝ │ │
┌─┴─╖ │ ╔═══╗ │
│ ! ║ │ ║ 1 ║ │
╘═╤═╝ │ ╚═╤═╝ │
│ ┌─┴─╖ ┌─┴─╖ │
│ │ ×ばつ ╟──┤ ? ╟──┘
│ ╘═╤═╝ ╘═╤═╝
└─────┘ │
Another example where I actually tried to golf in this language: Render "Digital Clock Style" Numbers
Funciton
Created by me and my personal favourite. This is a 2D language that uses Unicode box-drawing characters to create programs that resemble flowcharts, but the semantics are actually closer to that of a functional language than an actual flowchart. It has only five built-in operations (NAND, shift-left, less-than, function invocation and lambda expressions) and only one datatype (the arbitrary-size integer) and all the useful functions are implemented in terms of this. There is an entire library of functions for arithmetic, string handling, lists and lazy-evaluated sequences.
Example: The Factorial Function
╓───╖
║ ! ║
╙─┬─╜ ┌───╖ ╔═══╗
┌─────┴─────┤ > ╟──╢ 2 ║
│ ╘═╤═╝ ╚═══╝
╔════╗ ┌───╖ │ │
║ −1 ╟──┤ + ╟─┴─┐ │
╚════╝ ╘═╤═╝ │ │
┌─┴─╖ │ ╔═══╗ │
│ ! ║ │ ║ 1 ║ │
╘═╤═╝ │ ╚═╤═╝ │
│ ┌─┴─╖ ┌─┴─╖ │
│ │ ×ばつ ╟──┤ ? ╟──┘
│ ╘═╤═╝ ╘═╤═╝
└─────┘ │
Another example where I actually tried to golf in this language: Render "Digital Clock Style" Numbers