PageRenderTime 1093ms queryTime 51ms sortTime 10ms getByIdsTime 945ms findMatchingLines 50ms

22+ results for 'hello world lisp' (1093 ms)

Not the results you expected?
ert-x-tests.el https://github.com/T-force/emacs.git | Emacs Lisp | 273 lines
                    
24
                    
25;; This file is part of ERT, the Emacs Lisp Regression Testing tool.
                    
26;; See ert.el or the texinfo manual for more details.
                    
38  (ert-with-test-buffer (:name "well-indented")
                    
39    (insert (concat "(hello (world\n"
                    
40                    "        'elisp)\n"))
                    
40                    "        'elisp)\n"))
                    
41    (emacs-lisp-mode)
                    
42    (should (equal (ert-buffer-string-reindented) (buffer-string))))
                    
43  (ert-with-test-buffer (:name "badly-indented")
                    
44    (insert (concat "(hello\n"
                    
45                    "       world)"))
                    
45                    "       world)"))
                    
46    (emacs-lisp-mode)
                    
47    (should-not (equal (ert-buffer-string-reindented) (buffer-string)))))
                    
                
test.lisp https://github.com/vikram/lisplibraries.git | Lisp | 268 lines
                    
1;; -*- mode: Lisp; Syntax: Common-Lisp; -*-
                    
2;;;
                    
9
                    
10  (:use :common-lisp
                    
11        :closer-mop
                    
109(def serialize-deserialize-test uninterned-symbol/1 '#:a)
                    
110(def serialize-deserialize-test package/1 (find-package :common-lisp))
                    
111
                    
181(defvar k (with-call/cc
                    
182            (print "Hello")
                    
183            (let/cc k k)
                    
183            (let/cc k k)
                    
184            (print "World")))
                    
185
                    
                
language2.html https://gitlab.com/d4n1/d4n1 | HTML | 193 lines
                    
52  <div class="article_title">
                    
53    <h1><a href="http://www.d4n1.org/lisp.html">Lisp</a></h1>
                    
54  </div>
                    
55  <div class="article_text">
                    
56    <p>Lisp (historically, LISP) is a family of computer programming
                    
57languages with a long history and a distinctive, fully parenthesized
                    
76<div class="highlight"><pre><span></span><code>gst
                    
77&#39;Hello, world&#39;
                    
78</code></pre></div>
                    
113<span class="w">    </span><span class="k">var</span><span class="w"> </span><span class="n">window</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">new</span><span class="w"> </span><span class="n">Window</span><span class="w"> </span><span class="p">();</span><span class="w"></span>
                    
114<span class="w">    </span><span class="n">window</span><span class="o">.</span><span class="n">title</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s2">&quot;Hello, World!&quot;</span><span class="p">;</span><span class="w"></span>
                    
115<span class="w">    </span><span class="n">window</span><span class="o">.</span><span class="n">border_width</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">10</span><span class="p">;</span><span class="w"></span>
                    
144<h4>ghc</h4>
                    
145<div class="highlight"><pre><span></span><code>main = putStrLn \&quot;Hello World …</code></pre></div>
                    
146  </div>
                    
                
d4n110.html https://gitlab.com/d4n1/d4n1 | HTML | 199 lines
                    
61<h4>ghc</h4>
                    
62<div class="highlight"><pre><span></span><code>main = putStrLn \&quot;Hello World …</code></pre></div>
                    
63  </div>
                    
87by Yukihiro \"Matz\" Matsumoto in Japan. According to its creator,
                    
88Ruby was influenced by Perl, Smalltalk, Eiffel, Ada, and Lisp. It
                    
89supports multiple programming paradigms, including functional,
                    
122<span class="p">{</span><span class="w"></span>
                    
123<span class="w">    </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;Hello World&quot;</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">endl</span><span class="p">;</span><span class="w"></span>
                    
124<span class="p">}</span><span class="w"></span>
                    
                
Creating-amhello.html https://gitlab.com/Gentio/my-pdf | HTML | 235 lines
                    
29<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
                    
30<link href="Hello-World.html#Hello-World" rel="up" title="Hello World">
                    
31<link href="amhello_0027s-configure_002eac-Setup-Explained.html#amhello_0027s-configure_002eac-Setup-Explained" rel="next" title="amhello's configure.ac Setup Explained">
                    
31<link href="amhello_0027s-configure_002eac-Setup-Explained.html#amhello_0027s-configure_002eac-Setup-Explained" rel="next" title="amhello's configure.ac Setup Explained">
                    
32<link href="Hello-World.html#Hello-World" rel="prev" title="Hello World">
                    
33<style type="text/css">
                    
68<p>
                    
69Next: <a href="amhello_0027s-configure_002eac-Setup-Explained.html#amhello_0027s-configure_002eac-Setup-Explained" accesskey="n" rel="next">amhello's configure.ac Setup Explained</a>, Up: <a href="Hello-World.html#Hello-World" accesskey="u" rel="up">Hello World</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Indices.html#Indices" title="Index" rel="index">Index</a>]</p>
                    
70</div>
                    
197~/amhello % <kbd>src/hello</kbd>
                    
198Hello World!
                    
199This is amhello 1.0.
                    
228<p>
                    
229Next: <a href="amhello_0027s-configure_002eac-Setup-Explained.html#amhello_0027s-configure_002eac-Setup-Explained" accesskey="n" rel="next">amhello's configure.ac Setup Explained</a>, Up: <a href="Hello-World.html#Hello-World" accesskey="u" rel="up">Hello World</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Indices.html#Indices" title="Index" rel="index">Index</a>]</p>
                    
230</div>
                    
                
normal-template.js https://github.com/haxd/normal-template.git | JavaScript | 250 lines
                    
36    ]};
                    
37    assert.equal(t(data), "Hello1: World1 Hello2: World2 Hello3: World3 ");
                    
38
                    
90        {title: "Hello2", content: "World2"},
                    
91        {title: "Hello3", content: "World3"}
                    
92    ]};
                    
92    ]};
                    
93    assert.equal(t(data), "<li>Hello1: World1</li><li>Hello2: World2</li><li>Hello3: World3</li>");
                    
94
                    
109    ]};
                    
110    assert.equal(t(data), "<li>Hello1: World1</li><li>Hello2: World2</li><li>Hello3: World3</li>");
                    
111
                    
239    ]};
                    
240    assert.equal(t(data), "Hello1: World1,Hello2: World2,Hello3: World3");
                    
241
                    
                
zmsg.lisp https://github.com/pjkundert/zguide.git | Lisp | 271 lines
                    
1;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
                    
2;;;
                    
2;;;
                    
3;;;  Multipart message class for example applications in Common Lisp
                    
4;;;
                    
216        (let ((message (make-message)))
                    
217          (set-body message "Hello")
                    
218          (assert (string= (body message) "Hello"))
                    
224              (dump message))
                    
225            (assert (string= (body message) "Hello"))))
                    
226
                    
228        (let ((message (make-message)))
                    
229          (set-body message "Hello")
                    
230          (wrap message "address1" "")
                    
247            (assert (= (parts message) 4))
                    
248            (string= (body message) "World")
                    
249            (let ((part (unwrap message)))
                    
                
test.lisp https://github.com/vikram/lisplibraries.git | Lisp | 255 lines
                    
1;; -*- lisp -*-
                    
2
                    
89
                    
90(test hello-world
                    
91  (with-output-to-string (hello-world)
                    
97                                            (write-char (code-char byte) hello-world))))
                    
98      (is (string= "hello, world!" (get-output-stream-string hello-world)))))
                    
99  (with-output-to-string (hello-world)
                    
110                                          (lambda (byte)
                    
111                                            (write-char (code-char byte) hello-world))))
                    
112      (is (string= "
                    
112      (is (string= "
                    
113hello, world!" (get-output-stream-string hello-world))))))
                    
114
                    
                
code-block-exports-no-color.org https://github.com/wallyqs/org-ruby.git | Org | 466 lines
                    
96#+begin_src emacs-lisp
                    
97(message "hello world")
                    
98#+end_src
                    
158Hello world!
                    
159Hello world!
                    
160Hello world!
                    
356Hello world!
                    
357Hello world!
                    
358Hello world!
                    
362Hello world!
                    
363Hello world!
                    
364#+end_example
                    
409#+begin_src ruby :exports both
                    
410hello = <<HELLO
                    
411The following is a text
                    
                
README.md https://bitbucket.org/tonetheman/parenj.git | Markdown | 261 lines
                    
4
                    
5Paren is a dialect of Lisp. It is designed to be an embedded language. You can use Java in your Paren program.
                    
6
                    
40## Examples ##
                    
41### Hello, World! ###
                    
42```
                    
42```
                    
43(prn "Hello, World!")
                    
44```
                    
                
test-openpty.c https://gitlab.com/changlimin/gnulib | C | 111 lines
                    
17/* Written by Simon Josefsson <simon@josefsson.org>, 2009
                    
18   and Bruno Haible <bruno@clisp.org>, 2010.  */
                    
19
                    
75    {
                    
76      static const char input[] = "Hello worst\177\177ld!\n";
                    
77
                    
88      int res = read (slave, buf, sizeof (buf));
                    
89      static const char expected[] = "Hello world!\n";
                    
90
                    
                
tempo-tests.el https://gitlab.com/RobertCochran/emacs | Emacs Lisp | 228 lines
                    
86        (tempo-insert-template 'tempo-template-test nil))
                    
87      (should (equal (buffer-string) "hello world! world!")))))
                    
88
                    
183  (with-temp-buffer
                    
184    (tempo-define-template "test" '("Hello," nil " World!"))
                    
185    (tempo-insert-template 'tempo-template-test nil)
                    
213  (with-temp-buffer
                    
214    (tempo-define-template "test" '("Hello, World!") "hello")
                    
215    (insert "hello")
                    
221  (with-temp-buffer
                    
222    (tempo-define-template "test" '("Hello, World!") "hello")
                    
223    (insert "hel")
                    
224    (tempo-complete-tag)
                    
225    (should (equal (buffer-string) "Hello, World!"))))
                    
226
                    
                
README.md https://gitlab.com/nebogeo/co2 | Markdown | 619 lines
                    
1# co2: Lisp on NES/Famicom
                    
2
                    
2
                    
3A lisp for building NES/Famicom games.
                    
4
                    
237    (asm "mystring:")
                    
238    (text "hello world")
                    
239
                    
                
README.md https://gitlab.com/x33n/learnyounode | Markdown | 45 lines
                    
15
                    
16<b><code>learnyounode</code></b> will run through a series of Node.js workshops. Starting at a basic *"HELLO WORLD"* and moving on to more advanced exercises about dealing with synchronous & asynchronous I/O, filesystem operations, TCP and HTTP networking, events and streams.
                    
17
                    
30<tr><th align="left">Dan Flettre</th><td><a href="https://github.com/Flet">GitHub/Flet</a></td><td><a href="http://twitter.com/flettre">Twitter/@flettre</a></td></tr>
                    
31<tr><th align="left">Leigh Zhu</th><td><a href="https://github.com/lisposter">GitHub/lisposter</a></td><td><a href="http://twitter.com/lisposter">Twitter/@lisposter</a></td></tr>
                    
32<tr><th align="left">Lucas F. da Costa</th><td><a href="https://github.com/lucasfcosta">GitHub/lucasfcosta</a></td><td></td></tr>
                    
                
Assembly-Code.html https://gitlab.com/infected_/linaro_arm-linux-android-5.3.x | HTML | 133 lines
                    
35div.indentedblock {margin-left: 3.2em}
                    
36div.lisp {margin-left: 3.2em}
                    
37div.smalldisplay {margin-left: 3.2em}
                    
39div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
                    
40div.smalllisp {margin-left: 3.2em}
                    
41kbd {font-style:oblique}
                    
48pre.smallformat {font-family: inherit; font-size: smaller}
                    
49pre.smalllisp {font-size: smaller}
                    
50span.nocodebreak {white-space:nowrap}
                    
70
                    
71<p>This simple &ldquo;hello world&rdquo; example demonstrates several of the stab
                    
72types used to describe C language source files.
                    
9622 LC0:
                    
9723      .ascii &quot;Hello, world!\12\0&quot;
                    
9824      .align 4
                    
                
Inline.hs https://github.com/jgm/pandoc.git | Haskell | 393 lines
                    
27  [ "Plain String" =:
                    
28      "Hello, World" =?>
                    
29      para (spcSep [ "Hello,", "World" ])
                    
308                       )
                    
309                       "echo 'Hello, World'")
                    
310
                    
311  , "Inline code block with a blank argument array" =:
                    
312      "src_sh[]{echo 'Hello, World'}" =?>
                    
313    para (codeWith ( ""
                    
315                       , [ ("org-language", "sh") ])
                    
316                       "echo 'Hello, World'")
                    
317
                    
375                ] =?>
                    
376      para (emph "Hello, World")
                    
377
                    
                
hwserver.lisp https://github.com/pjkundert/zguide.git | Lisp | 37 lines
                    
1;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
                    
2;;;
                    
2;;;
                    
3;;;  Hello World server in Common Lisp
                    
4;;;  Binds REP socket to tcp://*:5555
                    
4;;;  Binds REP socket to tcp://*:5555
                    
5;;;  Expects "Hello" from client, replies with "World"
                    
6;;;
                    
33          ;; Send reply back to client
                    
34          (let ((reply (make-instance 'zmq:msg :data "World")))
                    
35            (zmq:send socket reply))))))
                    
                
code-block-exports-pygments.html https://github.com/wallyqs/org-ruby.git | HTML | 165 lines
                    
7<div class="highlight"><pre><span></span>#+begin_src ruby :results output :exports both
                    
8puts &quot;Hello world&quot;
                    
9#+end_src
                    
11#+RESULTS:
                    
12: Hello world
                    
13</pre></div>
                    
80  and its result should not be exported.</p>
                    
81<div class="highlight"><pre><span></span><span class="p">(</span><span class="nf">message</span> <span class="s">&quot;hello world&quot;</span><span class="p">)</span>
                    
82</pre></div>
                    
92  the same as when no option is set.</p>
                    
93<div class="highlight"><pre><span></span><span class="kd">var</span> <span class="nx">message</span> <span class="o">=</span> <span class="s2">&quot;Hello world!&quot;</span><span class="p">;</span>
                    
94
                    
97<p>And as block example too:</p>
                    
98<div class="highlight"><pre><span></span><span class="kd">var</span> <span class="nx">message</span> <span class="o">=</span> <span class="s2">&quot;Hello world!&quot;</span><span class="p">;</span>
                    
99<span class="k">for</span> <span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">&lt;</span> <span class="mi">10</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
                    
                
wu-tests.ts https://gitlab.com/CatchLabs/DefinitelyTyped | TypeScript | 411 lines
                    
194  it("should flatten iterables", () => {
                    
195    assert.eqArray(["I", "like", "LISP"],
                    
196                   wu(["I", ["like", ["LISP"]]]).flatten());
                    
225    Greeter.prototype.greet = function (tail) {
                    
226      return "hello " + this.name + tail;
                    
227    };
                    
227    };
                    
228    assert.eqArray(["hello world!", "hello test!"],
                    
229                   wu.invoke("greet", "!",
                    
229                   wu.invoke("greet", "!",
                    
230                             [new Greeter("world"), new Greeter("test")]));
                    
231  });
                    
                
elnode_tutorial.creole https://github.com/emish/emacs.git | Creole | 419 lines
                    
166
                    
167Let's make our Hello World example available again by binding it to
                    
168the default server (which is still listening on port 8000 if you
                    
173{{{
                    
174C-x b my-elnode-hello-world.el
                    
175}}}
                    
179{{{
                    
180(add-to-list 'elnode-hostpath-default-table '("/helloworld/" . my-elnode-hello-world-handler))
                    
181}}}
                    
190       "<html><body><h1>Hello World</h1></body></html>"))
                    
191(add-to-list 'elnode-hostpath-default-table '("/helloworld/" . my-elnode-hello-world-handler))
                    
192}}}
                    
207{{{
                    
208(("/helloworld/" . my-elnode-hello-world-handler)
                    
209("[^/]+/.*" . elnode-webserver))
                    
                
elnode-rle.el https://github.com/andreaja/dotemacs.git | Emacs Lisp | 387 lines
                    
40passed over the client-server link."
                    
41  (let* ((lisp-to-run (elnode-http-param httpcon "lisp"))
                    
42         (lisp
                    
57  :expected-result :failed
                    
58  (flet ((lisp-encode (param lisp)
                    
59           (cons param (format "%S" lisp)))
                    
75            ((lisp (lisp-encode
                    
76                    "lisp" '(let ((a "hello world!")) (princ a))))
                    
77             (bindings (lisp-encode
                    
83        (let*
                    
84            ((lisp (lisp-encode
                    
85                    "lisp" '(let ((a (+ b 10))) (princ a))))
                    
346               (make-hash '(("bindings" "((a \"hello\"))")
                    
347                            ("lisp" "(princ \"hello\")")))
                    
348               (current-buffer)
                    
                
demo.ui.js https://bitbucket.org/dudesl/turecuerdo.git | JavaScript | 178 lines
                    
40        });
                    
41        var b=["ActionScript","AppleScript","Asp","BASIC","C","C++","Clojure","COBOL","ColdFusion","Erlang","Fortran","Groovy","Haskell","Java","JavaScript","Lisp","Perl","PHP","Python","Ruby","Scala","Scheme"];
                    
42        a("#da-ex-autocomplete").autocomplete({
                    
159            a("#da-ex-growl").bind("click",function(d){
                    
160                a.jGrowl("Hello World!",{
                    
161                    position:"bottom-right"
                    
                
 

Source

Language