Nabd

== Description ==
A simple, functional esoteric programming language
The name is an acronym standing for "Not A B.f. Derivative."
Click here to go to the compiler's GitHub repo
Possibly going to be used as a basis for a functional graphical programming language.
== Modules ==
Code is organized into modules and the module file directories can be passed into the compiler with -I<folder name> like headers are included into gcc.
Modules can either be nabd code or C++ headers with a corresponding object file (determined by file extension).
For reference, look at the standard library implementation as that is a C++ library
== Instructions ==
I've placed spaces, but they're not required
Instruction 	Description
$ _ $ 	Reads code from the module within dollar signs. If a module contains $, an escape sequence (\$) can be used
_ = _ > _ . 	Define a function with name (first _) and parameter (second _) returning an expression (last _). Polymorphism is allowed.
_ ( _ ) 	Call function (first _) with parameter (second _)
[ _ , _ , _ , ... ]	Expression denoting a list with type first _ of comma separated sub expressions
'_' 	Expression denoting a string, just like in other programming languages
0d_# 	Expression denoting a decimal number.
0x_# 	Enter a number as hex
{ _ , _ } 	Expression denoting a tuple
! _ ? _ : _ 	If an expression converted to a number is > 0, then expression is first, otherwise second
Types:
* String - a character string
* Number - a decimal number
* Tuple - two objects of different types packed together
* List - a collection of objects of the same types
Note: all types can be converted to each other and will not error out. For instance, if a string is implicitly cast as a number, or the cast fails to convert it properly to a number, the first character will be converted to its ascii representation
Code is organized into functions, and the first function called is main, which takes a list of strings as an argument
== Examples ==
=== Hello World: ===
 $std$main=args>print('Hello, world!\n').
=== Truth Machine: ===
 $std$i1InfI0Stop=!loop>loop?i1InfI0Stop(print(1)):print(0d0#).main=args>i1InfI0Stop(parseNum(input(0d0#))).
Or, more cleanly:
 $std$
 i1InfI0Stop = loop >
 ! loop ? i1Inf0Stop(print(0d1#)) : print(0d0#).
 main = args >
 i1InfI0Stop(
 parseNuminput(0d0#))).
=== Guess The Number: ===
 $std$
 
 startGame = randNum > [
 print('Guess a number btwn 0 and 10: '),
 guessFor({ randNum, 0d2# }),
 print('The answer was '),
 print(randNum),
 print('\nEnter \'1\' to play again or \'0\' to quit: '),
 ! parseNum(input(0d0#)) ?
 startGame(round(random({ 0d0#, 0d10# }))) :
 0d0# ].
 
 guessFor = numAndAttempts > [
 print('Guess (integer): '),
 checkGuess({ parseNum(input(0d0#)), numAndAttempts }) ].
 
 checkGuess = inputAndTupNumAtt >
 ! eq({
 fst(inputAndTupNumAtt),
 fst(snd(inputAndTupNumAtt)) 
 }) ?
 print('You won!\n') :
 ! snd(snd(inputAndTupNumAtt)) ?
 ! gt({
 fst(inputAndTupNumAtt),
 fst(snd(inputAndTupNumAtt))
 }) ? [
 print('Too high!\n'),
 guessFor({
 fst(snd(inputAndTupNumAtt)),
 dec(snd(snd(inputAndTupNumAtt)))
 }) ] : [
 print('Too low!\n'),
 guessFor({
 fst(snd(inputAndTupNumAtt)),
 dec(snd(snd(inputAndTupNumAtt)))
 }) ] :
 print('You lose!\n'). 
 
 main = args >
 snd({[
 seedRandom(0x0#),
 print('Welcome to Guess the Number!\n'),
 startGame(round(random({ 0d0#, 0d10# }))) ], 0d0# }).
== Standard Library Functions ==
These are built-in functionality to add a lot to the language.
It will be increased overtime.
Function 	Description 	Is Implemented?
print 	prints the value passed in to stdout and returns the string printed to console 	Yes
input 	read a string from stdin. Does nothing with parameter 	Yes
len 	returns the length of what's passed in. For tuples it's always 2, for numbers it's 1, and for lists and strings it's the actual length 	Yes
swap 	takes the first item of the list parameter and interprets it as a number and returns a copy of the second item with its first-parameter-th index replaced by the third element. If the index is outside the second parameter, then it simply returns the original parameter.	Yes
parseNum 	don't just cast to a number, but try to actually parse a number out 	Yes
gt 	takes two inputs via a tuple, compares them, and returns 1 if param 1 > param 2 or -1 otherwise 	Yes
ls 	same as greater but with < 	Yes
eq 	same as greater but with = 	Yes
gte 	same as greater but with >= 	Yes
lse 	same as greater but with <= 	Yes
ne 	same as greater but with != 	Yes
seedRandom	takes a dummy parameter and seeds a random given the current time. Returns 0 	Yes
random 	given a tuple with range min to max, return a random number 	Yes
dup 	duplicates an item and creates a tuple of the two 	Yes
round 	returns input rounded to the nearest int 	Yes
floor 	returns input rounded down 	Yes
ceil 	returns input rounded up 	Yes
fst 	get first item of tuple 	Yes
snd 	get second item of tuple 	Yes
elem 	get first element of tuple and then get the item of the second tuple item 	Yes
inc 	increment a number 	Yes
dec 	decrement a number 	Yes
Category:Languages Category:Functional paradigm Category:Implemented