Inline Evaluation Adventure

Inline check for a long time, but not every programmer has the opportunity to use it. If you don’t, it is an opportunity to try it.

At this end I get a simple editor with some examples of code. The following examples are all edit and imposed, however not Running
have button to kill them. You can use Control-r UNTO
Run / evaluate Pieces of code you selected from within the editorial editors below.

To see this in action, put your cursor after the expression you want to check in the editor below. Then, press
Control-r (hold the Control Kumause while pressing the r
key). For example, if you want to check (+ 1 2 3)Set the cursor after closing pen ) and then press
Control-r. For the quantity, We will use ^r as shorthand for
Control-r from today.

1
;`-- Place cursor after 1 then hit ^r

"Gremlins are cuties!"
;                     `-- Place cursor after " then hit ^r

(+ 1 2 3)
;   `-- Place cursor after 1 then hit ^r

(+ 1 2 3)
;        `-- Place cursor after the ')' then hit ^r

(+ 1 (/ 8 2) (* 2 3) )
;           `-------`-` Place cursor after each ')' and then hit ^r

(+ 1
   (/ 8 2)
   (* 2 3))
;          `-- Place cursor after ')' and then hit ^r

 
;`-- Place cursor above this line and hit ^r

If you press ^rThe editor found the closest complete expression and sent it to a runtime session (repl) for evaluating. The result immediately appears beside your code, exactly where you look. There is no change in the context that the code run should be found.

You may notice that you can check the small portions of an expression, such as (/ 8 2)as easily with a perfect expression. You can also check the expressions running on several lines.

Intp languages ​​make it simple to write editor tools to do it. It is important to write a plugin editor to determine an expression deleted by the pen.

Sometimes, if I’m not sure about livelihoods or behaviors, instead of looking for them, I just try to evaluate them to see if they have a way I have to see if they have a way I have to see if they have the way I hope.

For example, I know I’m doing a function that deals with HTML in a
div On top of the editor, but I can’t remember if it’s called
show-html or display-html. Let’s check both of the expressions below to see who will work:

;; was it show-html or display-html??
(show-html "")
;;                                   `-- ^r eval here

(display-html "")
;;                                      `-- ^r eval here

In the inline check, I can easily find out which function means and If doing what I expected, all who didn’t leave the editor or breaking my flow.

The next instance, let’s apply the same method to know what is look,, move and reset tasks made.

In all examples following, try to evaluate each expression ^r
to see the results.

(look)

(move :east)

(reset)

Note how the look function returning data describing your location in a text adventure game, while the move The function allows you to navigate through this virtual world.

It provides an opportunity to show how Inline checks help us build and refine the code to increase.

EVALUATE (look) and (move :east) can work as a spartan interface in the game, but surely it is better to show this data using our
display-html function. Isn’t it? Right ??

Now if we examine the data that the look Function returns we can see it returns a Hash map In some sorts, with keys
:desc,, :seen,, :exit and so on. Each of these keys maps to
lanyard descriptions of the status of the game.

We will work in data formatting returned to look to some HTML we can show.

;; First lets see what data is returned
(look)

;; I see a :desc key that holds a description 
(get (look) :desc)

;; OK we have a description let's put that into an HTML string
(str "
" (get (look) :desc) "
")

;; Now let's display that HTML
(display-html (str "
" (get (look) :desc) "
"))

We can improve our code by breaking the paragraph tag in its own functions:

;; Evaluate this to define the paragraph function
(defn p (content) 
  (str "
" content "
"))

;; now let's see how it works
(p "Hello")

(display-html (p (get (look) :desc)))

Ok, now we’re getting somewhere. But we also need to format the things that :seen Inside:

(look)

;; Let's extract the :seen items
(get (look) :seen)

;; Add some context to the raw data
(str "You see: " (get (look) :seen))

;; put it in a paragraph
(p (str "You see: " (get (look) :seen)))

;; let's add the :desc and the :seen together
(str
  (p (get (look) :desc))
  (p (str "You see: " (get (look) :seen))))
 
;; then display it
(display-html
  (str
    (p (get (look) :desc))
    (p (str "You see: " (get (look) :seen)))))
		

So we built some code to format data returned from
look function as html.

So let’s put this code into a function and start working on the function instead of composing only expressions.

;; so here's our initial format function
(defn look-html (data)
  (str
    (p (get data :desc))
    (p (str "You see: " (get data :seen)))))

;; let's see if it's working
(look-html (look))

;; and finally
(display-html (look-html (look)))

Ok now we have look-html function we can reuse, but there is certain place for progress. If we look at the data returned to look function you see with also
:img-path. Let’s use that to add more outlook to see our game display.

;; let's build up an expression to format the :img-path as 
;; an img tag
(get (look) :img-path)
(str "")

;; let's insert the image tag into our look-html function
(defn look-html (data)
  (str
    ;; v-- added img here --v
    (str "")
    (p (get data :desc))
    (p (str "You see: " (get data :seen)))))

;; let's see if it's working
(look-html (look))

;; and let's take a look!
(display-html (look-html (look)))

Not bad for all. OK, now there’s only one piece of information left to add to our look-html function. If you have weighed the
(look) function you notice a :exits Entrance provides player signs which directions they can move from their current location.

I think we’re at the point where you can add the :exits Information on
look-html function.

;; here's the :exits data
(get (look) :exits)

;; Add the exits data to the function below:
(defn look-html (data)
  (str
    (str "")
    (p (get data :desc))
    (p (str "You see: " (get data :seen)))
    (p (str "Exits: "    ))))

;; test it out here to see if it's working
(look-html (look))

;; and finally take a look!
(display-html (look-html (look)))

Do you like to play?

Now we have built our look-html Functions, we will use Inline examination to explore text text.

Below there are many tasks of play interview. Using inline check, check each other to determine its purpose and effect the game in the game. It shows how the inline checks to serve as a development and The exploration tool.

(display-html (look-html (look)))
(move :east)

(stack)
(push :picture)
(peek)
(pop)

(unlock-function :_something?_)
(reset)

Don’t be afraid to improve the UI. Here are some suggestions:

• Make a looki function united with our display-html and look-html Works: (display-html (look-html (look)))
• Develop a movi function calling move and then looki To display the new location
• Extend your look-html function to indicate the (stack) INFORMATION
• Your own images, nothing can stop you from making your own images and use those in the game

And last?

Thanks for taking time to experienced inline examination.

As programmers, we often fall into cognitive ruts that restrict our expectations of what programming process. These mental ruts, in turn, limit the potential to what we do. I have observed the decisions through language designers, architectural advocates, and tools directly ignore or prevent this type of interactivity – a situation I see true without luck.

It’s hard to get people to try things out of their experience. It is natural to prevent unfamiliar ideas and reject it. Many reads it is likely to respond by reasoning that this type of interview is not necessary or useful. However, in my humble opinion, that is not true.

Yes, it can be toy toys within a toy editor, but this level of interview is very true. Clojure programmers – etc. Using similar checking capabilities – apply this technique every day to professional settings, from video services using yourself using yourself.

My argument is not that clojure or lisp is the most greater than other languages, but that examination of an important adoption of programming environment across the program around the program environment

By experiencing it itself, you can be encouraged to expect more from your programming languages ​​and tools even to make yourself.