05_Logical_Negation.olly

##########################################################
    Logical negation operations.  Notice that we used a 
    new logical operator the unary '-', logical negation 
    operator, in the last tutorial text.
##########################################################

#! NO_EXCEPT = false

def adder(x):

    def n():
        def n(y):x + y;
        -n
    ;
    n
;

let f = (adder '42')
let x = '8'

"x     = " << x  << endl
"f     = " << -f << endl
"(f x) = " << (f x) << endl
endl


##########################################################
    Most often we think of logical negation in true and
    false terms.  Below are some example.
##########################################################

let p = true
let q = false

"p & -q = " << (p & -q) << endl
"p | -q = " << (p | -q) << endl
"p ^ -q = " << (p ^ -q) << endl
endl


##########################################################
    So logical negation work oposite of the indetity 
    operator.  Getting the value of what it is applied
    to then inverts its value, if applicable, and places
    the result on the deque.  
##########################################################

let x = '42'
" x = " <<  (x) << endl
"-x = " << (-x) << endl
endl 


##########################################################
    Lets look again at the adder function again.  
##########################################################

def adder(x):

    def n():
        def n(y):x + y;
        -n
        # By invoking the negation of 'n' we are binding
        # or specializing the current scope to the funciton.
        # Then it is being left on the deque.  This way a
        # new function cn be curried and assigned, like we
        # do wiht the function 'f' below.  
    ;
    n
    # By invoke the evaluation of this variable 'n'
    # the internaly enclosed function of 'n' is then
    # left as the result of the evaluation on the deque.
;

let f = (adder '42')
let x = '8'

"x     = " << x  << endl
"f     = " << -f << endl  # Here wer are asking for the
                          # specification of 'f'.  So we
                          # can see the function.  
"(f x) = " << (f x) << endl
endl

##########################################################
    Notice one last thing concerning the negation of 'f'.
    The body of the function has been evaluated to all
    postscipt operations.  That happens during when the
    code is compiled, for most binary operators.  
##########################################################