Could some one please help me using a if clause in jess, I know the simple sintax but I'm trying to use an && operand so I can use two conditions, but nothing I try seems to work.
if((<(?x ?y) && (>=(?z ?s)) then
....
else
....
Jess has a very regular syntax which is quite unlike the Java syntax you're trying to emulate. All "operators" are actually functions, and use the same prefix syntax as function calls. It's always (op arg1 arg2 ...). The parentheses always surround the whole expression, not just the arguments.
So for example, the Java expression a < b is always (< ?a ?b) in Jess. There is no && operator, but rather, there is an and function. So the Java if (a < b && c > d) ... looks like (if (and (< ?a ?b) (> ?c ?s)) then ... in Jess.
Related
I am very briefly looking into Scheme and wondering if there is a way to do the following: add several operations to each outcome (#t and #f).
(if (something)
Do something //true, #t
Do one thing AND another thing)) //false, #t
As an example, given a defined procedure that takes an integer x. If it is greater than five --> print out a message. If it is less than five --> print out message AND set x to zero:
(if (> x 5)
"Greater than five"
"Less than or equal to 5", (= x 0))
To rephrase: I am looking for a mechanism that allows me to do the following (expressed in Java syntax):
if (cond) { //true
//Do this
}
else { //false
//Do this
//AND this
}
Just make it up as you go !
OK, so say you we're really stuck, you at least know if gives you two branches.
(if #t "a" "b") ; => "a"
(if #f "a" "b") ; => "b"
Well "a" and "b" could be anything, right? What if they were procedures instead?
(define (a) "10")
(define (b) "20")
(if #t (a) (b)) ; => "10"
(if #f (a) (b)) ; => "20"
OK and we know procedure bodies can evaluate any number of expressions in sequence. So we could expand a and b to something like
(define (a) (print "a is ") (print "10") (newline))
(define (b) (print "b is ") (print "20") (newline))
(if #t (a) (b)) ; "a is 10\n"
(if #f (a) (b)) ; "b is 20\n"
OK so maybe that's a little cumbersome to define a procedure every time you want a logic branch that needs to eval multiple expressions, but at least it works. You could then inline the procedures with lambdas to make your life a little easier
((if #t
(λ ()
(print "a")
(print "b")
(newline))
(λ ()
(print "c")
(print "d")
(newline)))) ; "ab\n"
((if #f
(λ ()
(print "a")
(print "b")
(newline))
(λ ()
(print "c")
(print "d")
(newline)))) ; "cd\n"
Well now you can't really say you're stuck anymore. Things may not look exactly the same way they do in Java (thankfully), but at least things are behaving as expected.
As you continue to learn the language and common idioms, you might stumble across cond and begin. They might make your life easier, but you have to understand there's nothing magical about them. You could've just have easily implemented these yourself.
You can make up everything as you go. This is one of the reasons I love scheme/racket. Next to nothing is holy/sacred and you can essentially implement anything you can imagine.
Here's the thing though, if in scheme is a lot different from if in the algol family. If in algol derivatives is a branch or conditional jump instruction; if directly alters the flow of the code. In scheme/lisps every if returns a value. It isn't quite a full function is lisps due to the limitation of the internal structure of the interpreter or compiler, but for most purposes you can treat it as just another function.
(if (something)
Do something //true, #t
Do one thing AND another thing)) //false, #t
Is wrong, what is really going on.
(if condition
(return value of this first exp) //true value
(return value or this second exp)) //false value
In scheme, when you want a function to have a side-effect, that is mutate state you have to be very explicit and it's a good idea to mark function that mutate state with a "!" at the end of the function name.
Procedures like set! vector-set! and the like return an unspecified value. If you want a side effect and a specific value or more than one side effect in a particular sequence, you have to wrap the whole thing up with begin. Additionally if you just (set! x 0) you only change the value of x in the local scope, which may not be what you wanted to do . Whatever bound symbol you used to pass x into the function still carries it's old value.(set-car, vector-set! and set-cell-contents! do modify the underlying state of the data structure called across lexical boundaries) Explicit recursion or hiding a value in a closure is often appropriate.
The syntax for begin is (begin exp1 ... expN). Begin evaluates each expression in turn, and returns the value of the last expression. The only was this is useful is if all expressions before the last create side effects (mutate state or perform I/O). Also keep in mind both define and each clause of a cond contain and implicit begin.
In Java the procedure that prints a string creates side effect. If is not the same as simply returning a string, which is what your first branch of the (if (> x 5) .. is doing.
So to simplify things, we will keep the string printing as a side effect, and the next or new value of x as the return value of the statment.
(cond ((> x 5) (display "Greater than five") (newline) x)
(else (display "Less than or equal to 5") (newline) 0))
or the nearly equivalent
(if (> x 5)
(begin (display "Greater than five") (newline) x)
(begin (display "Less than or equal to 5") (newline) 0))
Just use begin, which is pretty similar to a λ expression:
(if #t
(begin (displayln "Hello, world!") (displayln "wtf"))
(displayln "stdio.h"))
You can wrap pretty much anything you like into a begin expression. They are usually used for flow control, because everything within a begin is evaluated first, but since if is a macro (Created with define-syntax instead of define) it treats begin as just another expression.
I am trying to construct a function "number-crop" which takes three arguments x a b. If x is to the left of the closed interval [a, b] on the number line, then return a. If x is to the right of the interval, then return b. Otherwise, just return x. This is what I have:
(define (number-crop x a b)
(if (max x a b) x b)
(if (min x a b) x a))
I am returned with the error, "define: expected only one expression for the function body, but found 1 extra part". I am new to Racket so I am still trying to understand how if statements work within the language.
Scheme/Racket if expressions always have exactly one condition and exactly two branches. Since they are expressions, not statements, this makes them very useful, and they function much like the conditional “ternary” operator in languages in the C family. However, when you have multiple conditions, you likely want something closer to if...else if chains, which is provided via the cond form.
The cond form is just like if, except with the ability to have any number of “clauses” which are each determined by a single condition. Using cond, your number-crop function would look like this:
(define (number-crop x a b)
(cond
[(< x a) a]
[(> x b) b]
[else x]))
(Note that else is special inside of cond—it replaces the condition for the last clause, and it always runs if the other cases fail.)
This would likely work, but if you already have access to min and max, you don’t actually need to branch at all! If you use those two functions together, you can write number-crop with neither if nor cond:
(define (number-crop x a b)
(min (max a x) b))
This works because composing both min and max will effectively clamp the value within the given range, provided that a is always the minimum and b is always the maximum.
In Scheme (Racket), functions are defined to return one thing. In your case it is clear: the result of the operation you describe. However, Scheme is different from most imperative languages in several respects. For example, if you look at your expression inside the define, it contains two expressions, one after the other. This contradicts the "one expression that calculates the function" assumption in Scheme.
Moreover, even if you write it in an imperative language, you'd use nested ifs, that you can of course use here. Something along the lines of:
(define (number-crop x a b)
(if (= x (max x a b))
b
(if (= x (min x a b))
a
x)))
Is there a way in lisp-family (EDIT: lisp-1) languages to differentiate symbol evaluation with regard to its position as as function or as an argument (i.e. override eval of this symbol in regard to when it is evaluated)?
As an example (I don't need this functionality, this is an example), I wanted to implement some sort of infix operation on a set of objects, which can be called by an object itself
(my-obj some-operator arg1 ...)
which will actually apply function some-operator to my-obj and arguments.
But when this object is used anywhere else in code as an argument, like:
(some-function my-obj &args...)
it will evaluate to a value of my-obj.
Thank you.
In Racket it is possible to do a couple things in this spirit:
You can define a struct and give it a prop:procedure. When an instance of the struct is supplied in an application, the procedure will be called.
You can override the default #%app with your own function, to redefine application generally, and including things that aren't structs. For example you can do things like emulate Clojure's (key map) syntax, so that ('symbol dict) is actually (hash-ref dict 'symbol).
Being a lisp-1 basically means that you do not evaluate the first slot of a combination any differently than any other slots. To get such behavior for code you write anyway, you need to transform it to code that does what you want under the rules of a lisp-1. Thus you will need to implement a macro that performs this transformation.
For example if you want infix operators you need to write some macro infix and then perhaps you could write:
(infix (+ - * /) (1 + 2 * 5 - 3) / 4)
and have it evaluate to 2.
I have been playing around with the idea of a default procedure in a OO CLOS-like Scheme. eg. that writing
(obj 5 10)
Would validate obj and apply it with arguments if obj is a procedure or method, but if it isn't it would be the same as the default dispatcher eg.
(default-dispatcher obj 5 10)
In such Scheme one could make vector accessors:
(define-method default-dispatcher
"Default dispatcher for vectors"
([obj %vector] [index %number]) -> (vector-ref obj index)
([obj %vector] [index %number] value) -> (vector-set! obj index value)
(args ...) -> (error "No such method"))
; example usage
(define vec (vector 4 5 6 7))
[vec 1] ; => 5
[vec 1 10]
[vec 1] ; => 10
In Racket this is possible by changing the languages #%app syntax.
In the TXR Lisp dialect, the problem is approached from the other end. Starting with Lisp-2 dialect as a basis, can we robe ourselves with some of the expressivity advantages of a Lisp-1 dialect, like eliminating the (function ...), #' and funcall noise from programs that make extensive use of higher order functions?
The design is centered around a special operator called dwim, which stands for either "Do What I Mean" or "Dispatch, in a Way that is Intelligent and Meaningful".
Invocations of the dwim operator are sugared over using square brackets, which are called "DWIM Brackets"
The dwim operator isn't just a macro over Lisp-2; it actually changes the name lookup rules. When we have
(dwim a b c (d e f) g)
Or equivalently:
[a b c (d e f) g]
all of the argument forms which are symbolic (a, b, c and g) are resolved using a special rule which conflates together the function and variable namespaces. This is built into the heart of the language. The operator has direct access to the environment to make this possible.
The special treatment does not recurse into (d e f), which is an ordinary Lisp-2 form. You have to put the DWIM Brackets on that if you want the semantics.
Also, the dwim operator is properly handled by macro expansion. For instance, given:
(symacrolet ((localfun whatever))
(flet ((localfun () ...)))
[a b c localfun] ;; refers to the flet as a function object!
(a b c localfun))) ;; refers to the symbol macro!
The macro expander knows about dwim and its semantics, and so it considers the possibility that localfun refers to the function and variable namespace. The closest lexical binding in either namespace is the flet and so the symbol macro expansion is suppressed (shadowed).
The dwim semantics is implicitly used in the partial evaluating op macro and its "cousins" derived from it.
Range Extraction task from Rosetta Code:
(defun range-extract (numbers)
`#{(mapcar [iff [callf > length (ret 2)]
(ret `#[#1 0]-#[#1 -1]`)
(ret `#{#1 ","}`)]
(mapcar (op mapcar car)
(split [window-map 1 :reflect
(op list #2 (- #2 #1))
(sort (uniq numbers))]
(op where [chain second (op < 1)])))) ","}`)
Y Combinator:
;; The Y combinator:
(defun y (f)
[(op #1 #1)
(op f (op [##1 ##1]))])
;; The Y-combinator-based factorial:
(defun fac (f)
(do if (zerop #1)
1
(* #1 [f (- #1 1)])))
;; Test:
(format t "~s\n" [[y fac] 4])
Moreover, various useful things are function callable in TXR Lisp. For instance, every sequence (list, vector or character string) is regarded as a function which maps numeric indices to elements. Thus we can do:
(mapcar "abc" #(2 1 0)) -> #(#\c #\b #\a)
The accepted answer describes a Racket mechanism for treating structures as functions. TXR has this in the form of lambda methods. This is demonstrated in the "OOP-Based" solution to the Accumulator Factory task in Rosetta:
(defstruct (accum count) nil
(count 0))
(defmeth accum lambda (self : (delta 1))
(inc self.count delta))
We can instantiate a (new (accum 9)) which will produce the values 10, 11, 12, ... when invoked as a function. An optional delta argument can be supplied for an increment other than 1:
(let ((acc (new (accum 0))))
(list [acc 5] [acc 5] [acc])) -> (5 10 11)
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 8 years ago.
Improve this question
What's the equivalence in scheme for the following code?
if (condition)
{
function1;
function2;
}
else
{
function3;
function4;
}
Thanks.
The parallel code where the code executes a block for each of the true and false branches is:
(if (condition)
(begin
(function1)
(function2))
(begin
(function3)
(function4)))
It depends. You really should try to narrow you question further with an actual problem in scheme since the answer will depend on what you are trying to do.
In idiomatic Scheme most should be done without side effects so you have
(if predicate-expression
consequent-expression
alternative-expression) ;; alternative is optional but should be used anyway.
But with your code you have more than one thing in the branches, something like:
int test (condition)
{
if (condition)
{
function1();
return function2();
}
else
{
function3();
return function4();
}
}
Here, in order for function1 and function3 to do anything useful it has to mutate, read or write something, also called a side effect. You should try to avoid that so in Scheme you either use a let to store a temporary variable, do the call so when it returns it is used like this:
(define (test condition)
(if condition
(let ((tmp (function3)))
(function4 tmp))
(function4 (function3))))
Now. You will eventually need side effects for a few procedures and then you need to use begin or use cond which has explicit begin.
(if predicate-expression
(begin
consequent-side-effect-expression
consequent-tail-expression)
(begin
alternative-side-effect-expression
alternative-tail-expression))
Now begin joins together several expressions into one and the result of a begin block is it's last expression, thus you can even use it in the predicate. Cond has an explicit begin in every consequent so I often switch from if to cond when I either need more than one consequent or a begin:
(cond (predicate-expression consequent-side-effect-expression
consequent-tail-expression)
(predicate2-expression consequent2-tail-expression2)
(else alternative-side-effect-expression
alternative-tail-expression))
Often when there is side effects you not always need the alternative. Eg. you are actually not interested in what the if returns because it may not be in tail position either. In these cases you have in the (rnrs control (6)) library when and unless with explicit begin:
(when expression
consequent-side-effect-expression
...
consequent-tail-expression)
(unless expression
consequent-side-effect-expression
...
consequent-tail-expression)
A let or a procedure also has explicit begin:
(let ()
(display "hello") ; displays "hello"
5) ; returns 5
(define (test x)
(display x) ; display x
(+ x 5)) ; return x+5
How about
(if condition
then-code
else-code)
Scheme also has the more general
(cond
((test1) case-1)
((test2) case-2)
...
(else else-case))
If you are using Racket, then
(when test then-code)
is if without the else.
There are a few Intro to Scheme sites that cover this sort of thing. Here's an example from the link included:
(define (min a b)
(if (< a b)
a
b))
WorBlux replied in another thread:
(if condition1 (begin function1 function2) (begin function3
function4)) 'begin' is a procedure/macro that forces sequential
evaluation of each of its arguments from left to right, and returns
the value of the last argument evaluated. In the cond form each clause
is wrapped in an implicit begin. Also the define special form is also
so wrapped, so you can do (cond (condition1 function1 function2) (else
function3 function4)) – WorBlux
I was just curious, looking around, it seems that Javascript does not have a equals() method like Java. Also, neither == or === can be used to check iff the two operators are the same item. So how is it that Clojurescript has a == and a identical? operator?
Also, should I expect identical? to be substantially faster than == in Clojurescript?
Here's a quick result from the Himera ClojureScript REPL:
cljs.user> =
#<function (a, b) {
return cljs.core._equiv.call(null, a, b)
}>
cljs.user> ==
#<function (a, d, e) {
switch(arguments.length) {
case 1:
return!0;
case 2:
return cljs.core._equiv.call(null, a, d);
default:
return b.apply(this, arguments)
}
throw"Invalid arity: " + arguments.length;
}>
cljs.user> identical?
#<function (a, b) {
return a === b
}>
According to Mozilla's JavaScript Reference on Comparison Operators the === operator does compare to see if the two operands are the same object instance, and since identical? in clojurescript maps directly onto === in JavaScript it will therefore do just that.
The fact that identical? maps directly onto a === b would also suggest that it'll be significantly faster than = or == since they both translate to calls to cljs.core._equiv. However, it wouldn't surprise me if a good JavaScript JIT engine reduced all three to very similar machine code for numbers since the -equiv implementation for numbers just maps onto identical?:
(extend-type number
IEquiv
(-equiv [x o] (identical? x o))
It looks like it's just a macro for ===
https://github.com/clojure/clojurescript/blob/master/src/clj/cljs/core.clj#L208
Update based on #dnolen's comment
It's also a function, which just calls ===:
https://github.com/clojure/clojurescript/blob/master/src/cljs/cljs/core.cljs#L43